diff --git a/src/Flecs.NET.Bindings/Flecs.NET.Bindings.csproj b/src/Flecs.NET.Bindings/Flecs.NET.Bindings.csproj
index d0308683..e898054b 100644
--- a/src/Flecs.NET.Bindings/Flecs.NET.Bindings.csproj
+++ b/src/Flecs.NET.Bindings/Flecs.NET.Bindings.csproj
@@ -10,7 +10,7 @@
         <IsPackable>true</IsPackable>
         <IncludeContentInPack>true</IncludeContentInPack>
 
-        <Version>4.0.0</Version>
+        <Version>4.0.1</Version>
         <Title Condition="'$(Configuration)' == 'Debug'">Flecs.NET.Bindings.Debug</Title>
         <Title Condition="'$(Configuration)' == 'Release'">Flecs.NET.Bindings.Release</Title>
         <Authors>BeanCheeseBurrito</Authors>
diff --git a/src/Flecs.NET.Bindings/Flecs.g.cs b/src/Flecs.NET.Bindings/Flecs.g.cs
index a78d92db..a18efd0f 100644
--- a/src/Flecs.NET.Bindings/Flecs.g.cs
+++ b/src/Flecs.NET.Bindings/Flecs.g.cs
@@ -202,9 +202,6 @@ public static unsafe partial class flecs
         [System.Runtime.InteropServices.DllImport(BindgenInternal.DllImportPath, EntryPoint = "ecs_entity_from_json", CallingConvention = System.Runtime.InteropServices.CallingConvention.Cdecl)]
         public static extern byte* ecs_entity_from_json(ecs_world_t* world, ulong entity, byte* json, ecs_from_json_desc_t* desc);
 
-        [System.Runtime.InteropServices.DllImport(BindgenInternal.DllImportPath, EntryPoint = "ecs_entity_from_json_legacy", CallingConvention = System.Runtime.InteropServices.CallingConvention.Cdecl)]
-        public static extern byte* ecs_entity_from_json_legacy(ecs_world_t* world, ulong entity, byte* json, ecs_from_json_desc_t* desc);
-
         [System.Runtime.InteropServices.DllImport(BindgenInternal.DllImportPath, EntryPoint = "ecs_entity_init", CallingConvention = System.Runtime.InteropServices.CallingConvention.Cdecl)]
         public static extern ulong ecs_entity_init(ecs_world_t* world, ecs_entity_desc_t* desc);
 
@@ -223,32 +220,35 @@ public static unsafe partial class flecs
         [System.Runtime.InteropServices.DllImport(BindgenInternal.DllImportPath, EntryPoint = "ecs_exists", CallingConvention = System.Runtime.InteropServices.CallingConvention.Cdecl)]
         public static extern byte ecs_exists(ecs_world_t* world, ulong entity);
 
+        [System.Runtime.InteropServices.DllImport(BindgenInternal.DllImportPath, EntryPoint = "ecs_field_at_w_size", CallingConvention = System.Runtime.InteropServices.CallingConvention.Cdecl)]
+        public static extern void* ecs_field_at_w_size(ecs_iter_t* it, System.IntPtr size, byte index, int row);
+
         [System.Runtime.InteropServices.DllImport(BindgenInternal.DllImportPath, EntryPoint = "ecs_field_column", CallingConvention = System.Runtime.InteropServices.CallingConvention.Cdecl)]
-        public static extern int ecs_field_column(ecs_iter_t* it, int index);
+        public static extern int ecs_field_column(ecs_iter_t* it, byte index);
 
         [System.Runtime.InteropServices.DllImport(BindgenInternal.DllImportPath, EntryPoint = "ecs_field_id", CallingConvention = System.Runtime.InteropServices.CallingConvention.Cdecl)]
-        public static extern ulong ecs_field_id(ecs_iter_t* it, int index);
+        public static extern ulong ecs_field_id(ecs_iter_t* it, byte index);
 
         [System.Runtime.InteropServices.DllImport(BindgenInternal.DllImportPath, EntryPoint = "ecs_field_is_readonly", CallingConvention = System.Runtime.InteropServices.CallingConvention.Cdecl)]
-        public static extern byte ecs_field_is_readonly(ecs_iter_t* it, int index);
+        public static extern byte ecs_field_is_readonly(ecs_iter_t* it, byte index);
 
         [System.Runtime.InteropServices.DllImport(BindgenInternal.DllImportPath, EntryPoint = "ecs_field_is_self", CallingConvention = System.Runtime.InteropServices.CallingConvention.Cdecl)]
-        public static extern byte ecs_field_is_self(ecs_iter_t* it, int index);
+        public static extern byte ecs_field_is_self(ecs_iter_t* it, byte index);
 
         [System.Runtime.InteropServices.DllImport(BindgenInternal.DllImportPath, EntryPoint = "ecs_field_is_set", CallingConvention = System.Runtime.InteropServices.CallingConvention.Cdecl)]
-        public static extern byte ecs_field_is_set(ecs_iter_t* it, int index);
+        public static extern byte ecs_field_is_set(ecs_iter_t* it, byte index);
 
         [System.Runtime.InteropServices.DllImport(BindgenInternal.DllImportPath, EntryPoint = "ecs_field_is_writeonly", CallingConvention = System.Runtime.InteropServices.CallingConvention.Cdecl)]
-        public static extern byte ecs_field_is_writeonly(ecs_iter_t* it, int index);
+        public static extern byte ecs_field_is_writeonly(ecs_iter_t* it, byte index);
 
         [System.Runtime.InteropServices.DllImport(BindgenInternal.DllImportPath, EntryPoint = "ecs_field_size", CallingConvention = System.Runtime.InteropServices.CallingConvention.Cdecl)]
-        public static extern System.IntPtr ecs_field_size(ecs_iter_t* it, int index);
+        public static extern System.IntPtr ecs_field_size(ecs_iter_t* it, byte index);
 
         [System.Runtime.InteropServices.DllImport(BindgenInternal.DllImportPath, EntryPoint = "ecs_field_src", CallingConvention = System.Runtime.InteropServices.CallingConvention.Cdecl)]
-        public static extern ulong ecs_field_src(ecs_iter_t* it, int index);
+        public static extern ulong ecs_field_src(ecs_iter_t* it, byte index);
 
         [System.Runtime.InteropServices.DllImport(BindgenInternal.DllImportPath, EntryPoint = "ecs_field_w_size", CallingConvention = System.Runtime.InteropServices.CallingConvention.Cdecl)]
-        public static extern void* ecs_field_w_size(ecs_iter_t* it, System.IntPtr size, int index);
+        public static extern void* ecs_field_w_size(ecs_iter_t* it, System.IntPtr size, byte index);
 
         [System.Runtime.InteropServices.DllImport(BindgenInternal.DllImportPath, EntryPoint = "ecs_fini", CallingConvention = System.Runtime.InteropServices.CallingConvention.Cdecl)]
         public static extern int ecs_fini(ecs_world_t* world);
@@ -1348,6 +1348,9 @@ public static unsafe partial class flecs
         [System.Runtime.InteropServices.DllImport(BindgenInternal.DllImportPath, EntryPoint = "ecs_table_count", CallingConvention = System.Runtime.InteropServices.CallingConvention.Cdecl)]
         public static extern int ecs_table_count(ecs_table_t* table);
 
+        [System.Runtime.InteropServices.DllImport(BindgenInternal.DllImportPath, EntryPoint = "ecs_table_entities", CallingConvention = System.Runtime.InteropServices.CallingConvention.Cdecl)]
+        public static extern ulong* ecs_table_entities(ecs_table_t* table);
+
         [System.Runtime.InteropServices.DllImport(BindgenInternal.DllImportPath, EntryPoint = "ecs_table_find", CallingConvention = System.Runtime.InteropServices.CallingConvention.Cdecl)]
         public static extern ecs_table_t* ecs_table_find(ecs_world_t* world, ulong* ids, int id_count);
 
@@ -1384,6 +1387,9 @@ public static unsafe partial class flecs
         [System.Runtime.InteropServices.DllImport(BindgenInternal.DllImportPath, EntryPoint = "ecs_table_remove_id", CallingConvention = System.Runtime.InteropServices.CallingConvention.Cdecl)]
         public static extern ecs_table_t* ecs_table_remove_id(ecs_world_t* world, ecs_table_t* table, ulong id);
 
+        [System.Runtime.InteropServices.DllImport(BindgenInternal.DllImportPath, EntryPoint = "ecs_table_size", CallingConvention = System.Runtime.InteropServices.CallingConvention.Cdecl)]
+        public static extern int ecs_table_size(ecs_table_t* table);
+
         [System.Runtime.InteropServices.DllImport(BindgenInternal.DllImportPath, EntryPoint = "ecs_table_str", CallingConvention = System.Runtime.InteropServices.CallingConvention.Cdecl)]
         public static extern byte* ecs_table_str(ecs_world_t* world, ecs_table_t* table);
 
@@ -1558,12 +1564,6 @@ public static unsafe partial class flecs
         [System.Runtime.InteropServices.DllImport(BindgenInternal.DllImportPath, EntryPoint = "ecs_world_from_json_file", CallingConvention = System.Runtime.InteropServices.CallingConvention.Cdecl)]
         public static extern byte* ecs_world_from_json_file(ecs_world_t* world, byte* filename, ecs_from_json_desc_t* desc);
 
-        [System.Runtime.InteropServices.DllImport(BindgenInternal.DllImportPath, EntryPoint = "ecs_world_from_json_file_legacy", CallingConvention = System.Runtime.InteropServices.CallingConvention.Cdecl)]
-        public static extern byte* ecs_world_from_json_file_legacy(ecs_world_t* world, byte* filename, ecs_from_json_desc_t* desc);
-
-        [System.Runtime.InteropServices.DllImport(BindgenInternal.DllImportPath, EntryPoint = "ecs_world_from_json_legacy", CallingConvention = System.Runtime.InteropServices.CallingConvention.Cdecl)]
-        public static extern byte* ecs_world_from_json_legacy(ecs_world_t* world, byte* json, ecs_from_json_desc_t* desc);
-
         [System.Runtime.InteropServices.DllImport(BindgenInternal.DllImportPath, EntryPoint = "ecs_world_stats_copy_last", CallingConvention = System.Runtime.InteropServices.CallingConvention.Cdecl)]
         public static extern void ecs_world_stats_copy_last(ecs_world_stats_t* dst, ecs_world_stats_t* src);
 
@@ -2864,7 +2864,7 @@ public partial struct ecs_each_iter_t : System.IEquatable<ecs_each_iter_t>
 
             public int columns;
 
-            public void* ptrs;
+            public ecs_table_record_t* trs;
 
             public bool Equals(ecs_each_iter_t other)
             {
@@ -4370,8 +4370,6 @@ public partial struct ecs_iter_t : System.IEquatable<ecs_iter_t>
 
             public ulong* entities;
 
-            public void** ptrs;
-
             public int* sizes;
 
             public ecs_table_t* table;
@@ -4382,7 +4380,7 @@ public partial struct ecs_iter_t : System.IEquatable<ecs_iter_t>
 
             public ecs_var_t* variables;
 
-            public int* columns;
+            public ecs_table_record_t** trs;
 
             public ulong* sources;
 
@@ -4390,11 +4388,11 @@ public partial struct ecs_iter_t : System.IEquatable<ecs_iter_t>
 
             public ulong group_id;
 
-            public int field_count;
-
             public uint set_fields;
 
-            public uint shared_fields;
+            public uint ref_fields;
+
+            public uint row_fields;
 
             public uint up_fields;
 
@@ -4406,11 +4404,13 @@ public partial struct ecs_iter_t : System.IEquatable<ecs_iter_t>
 
             public int event_cur;
 
-            public ecs_query_t* query;
+            public byte field_count;
+
+            public byte term_index;
 
-            public int term_index;
+            public byte variable_count;
 
-            public int variable_count;
+            public ecs_query_t* query;
 
             public byte** variable_names;
 
@@ -4720,6 +4720,8 @@ public partial struct ecs_member_t : System.IEquatable<ecs_member_t>
 
             public ulong unit;
 
+            public byte use_offset;
+
             public ecs_member_value_range_t range;
 
             public ecs_member_value_range_t error_range;
@@ -5326,7 +5328,7 @@ public partial struct ecs_observer_desc_t : System.IEquatable<ecs_observer_desc_
 
             public int* last_event_id;
 
-            public int term_index_;
+            public byte term_index_;
 
             public uint flags_;
 
@@ -6405,7 +6407,7 @@ public partial struct ecs_query_t : System.IEquatable<ecs_query_t>
 
             public uint flags;
 
-            public short var_count;
+            public byte var_count;
 
             public byte term_count;
 
@@ -6421,6 +6423,8 @@ public partial struct ecs_query_t : System.IEquatable<ecs_query_t>
 
             public uint read_fields;
 
+            public uint row_fields;
+
             public uint shared_readonly_fields;
 
             public uint set_fields;
@@ -8162,46 +8166,50 @@ public override int GetHashCode()
             }
         }
 
-        public partial struct ecs_table_cache_iter_t : System.IEquatable<ecs_table_cache_iter_t>
+        public partial struct ecs_table_cache_hdr_t : System.IEquatable<ecs_table_cache_hdr_t>
         {
-            public ecs_table_cache_hdr_t* cur;
+            public ecs_table_cache_t* cache;
+
+            public ecs_table_t* table;
+
+            public ecs_table_cache_hdr_t* prev;
 
             public ecs_table_cache_hdr_t* next;
 
-            public ecs_table_cache_hdr_t* next_list;
+            public byte empty;
 
-            public partial struct ecs_table_cache_hdr_t : System.IEquatable<ecs_table_cache_hdr_t>
+            public partial struct ecs_table_cache_t : System.IEquatable<ecs_table_cache_t>
             {
-                public bool Equals(ecs_table_cache_hdr_t other)
+                public bool Equals(ecs_table_cache_t other)
                 {
-                    fixed (ecs_table_cache_hdr_t* __self = &this)
+                    fixed (ecs_table_cache_t* __self = &this)
                     {
-                        return System.MemoryExtensions.SequenceEqual(new System.ReadOnlySpan<byte>((byte*)__self, sizeof(ecs_table_cache_hdr_t)), new System.ReadOnlySpan<byte>((byte*)&other, sizeof(ecs_table_cache_hdr_t)));
+                        return System.MemoryExtensions.SequenceEqual(new System.ReadOnlySpan<byte>((byte*)__self, sizeof(ecs_table_cache_t)), new System.ReadOnlySpan<byte>((byte*)&other, sizeof(ecs_table_cache_t)));
                     }
                 }
 
                 public override bool Equals(object? obj)
                 {
-                    return obj is ecs_table_cache_hdr_t other && Equals(other);
+                    return obj is ecs_table_cache_t other && Equals(other);
                 }
 
-                public static bool operator ==(ecs_table_cache_hdr_t left, ecs_table_cache_hdr_t right)
+                public static bool operator ==(ecs_table_cache_t left, ecs_table_cache_t right)
                 {
                     return left.Equals(right);
                 }
 
-                public static bool operator !=(ecs_table_cache_hdr_t left, ecs_table_cache_hdr_t right)
+                public static bool operator !=(ecs_table_cache_t left, ecs_table_cache_t right)
                 {
                     return !(left == right);
                 }
 
                 public override int GetHashCode()
                 {
-                    fixed (ecs_table_cache_hdr_t* __self = &this)
+                    fixed (ecs_table_cache_t* __self = &this)
                     {
 #if NET6_0_OR_GREATER
                     System.HashCode hash = new System.HashCode();
-                    hash.AddBytes(new System.ReadOnlySpan<byte>((byte*)__self, sizeof(ecs_table_cache_hdr_t)));
+                    hash.AddBytes(new System.ReadOnlySpan<byte>((byte*)__self, sizeof(ecs_table_cache_t)));
                     return hash.ToHashCode();
 #else
                         return base.GetHashCode();
@@ -8210,6 +8218,52 @@ public override int GetHashCode()
                 }
             }
 
+            public bool Equals(ecs_table_cache_hdr_t other)
+            {
+                fixed (ecs_table_cache_hdr_t* __self = &this)
+                {
+                    return System.MemoryExtensions.SequenceEqual(new System.ReadOnlySpan<byte>((byte*)__self, sizeof(ecs_table_cache_hdr_t)), new System.ReadOnlySpan<byte>((byte*)&other, sizeof(ecs_table_cache_hdr_t)));
+                }
+            }
+
+            public override bool Equals(object? obj)
+            {
+                return obj is ecs_table_cache_hdr_t other && Equals(other);
+            }
+
+            public static bool operator ==(ecs_table_cache_hdr_t left, ecs_table_cache_hdr_t right)
+            {
+                return left.Equals(right);
+            }
+
+            public static bool operator !=(ecs_table_cache_hdr_t left, ecs_table_cache_hdr_t right)
+            {
+                return !(left == right);
+            }
+
+            public override int GetHashCode()
+            {
+                fixed (ecs_table_cache_hdr_t* __self = &this)
+                {
+#if NET6_0_OR_GREATER
+                    System.HashCode hash = new System.HashCode();
+                    hash.AddBytes(new System.ReadOnlySpan<byte>((byte*)__self, sizeof(ecs_table_cache_hdr_t)));
+                    return hash.ToHashCode();
+#else
+                    return base.GetHashCode();
+#endif
+                }
+            }
+        }
+
+        public partial struct ecs_table_cache_iter_t : System.IEquatable<ecs_table_cache_iter_t>
+        {
+            public ecs_table_cache_hdr_t* cur;
+
+            public ecs_table_cache_hdr_t* next;
+
+            public ecs_table_cache_hdr_t* next_list;
+
             public bool Equals(ecs_table_cache_iter_t other)
             {
                 fixed (ecs_table_cache_iter_t* __self = &this)
@@ -8296,6 +8350,14 @@ public override int GetHashCode()
 
         public partial struct ecs_table_record_t : System.IEquatable<ecs_table_record_t>
         {
+            public ecs_table_cache_hdr_t hdr;
+
+            public short index;
+
+            public short count;
+
+            public short column;
+
             public bool Equals(ecs_table_record_t other)
             {
                 fixed (ecs_table_record_t* __self = &this)
@@ -8434,7 +8496,7 @@ public partial struct ecs_term_t : System.IEquatable<ecs_term_t>
 
             public short oper;
 
-            public short field_index;
+            public byte field_index;
 
             public ushort flags_;
 
@@ -10252,6 +10314,8 @@ public partial struct EcsMember : System.IEquatable<EcsMember>
 
             public int offset;
 
+            public byte use_offset;
+
             public bool Equals(EcsMember other)
             {
                 fixed (EcsMember* __self = &this)
@@ -11852,6 +11916,8 @@ public enum ecs_type_kind_t : uint
 
         public const uint EcsIdIsSparse = 16777216;
 
+        public const uint EcsIdIsTransitive = 16384;
+
         public const uint EcsIdIsUnion = 33554432;
 
         public const uint EcsIdMarkedForDelete = 1073741824;
@@ -11924,12 +11990,8 @@ public enum ecs_type_kind_t : uint
 
         public const uint EcsIterTrivialSearch = 256;
 
-        public const uint EcsIterTrivialSearchNoData = 512;
-
         public const uint EcsIterTrivialTest = 2048;
 
-        public const uint EcsIterTrivialTestNoData = 4096;
-
         public const int EcsIterYield = -1;
 
         public const uint EcsObserverBypassQuery = 32;
@@ -11970,8 +12032,6 @@ public enum ecs_type_kind_t : uint
 
         public const uint EcsQueryHasScopes = 131072;
 
-        public const uint EcsQueryHasSparseThis = 67108864;
-
         public const uint EcsQueryHasTableThisVar = 33554432;
 
         public const uint EcsQueryIsCacheable = 16777216;
@@ -11992,8 +12052,6 @@ public enum ecs_type_kind_t : uint
 
         public const uint EcsQueryMatchWildcards = 16384;
 
-        public const uint EcsQueryNoData = 16;
-
         public const uint EcsQueryTableOnly = 128;
 
         public const ulong EcsSelf = 9223372036854775808;
@@ -12082,8 +12140,6 @@ public enum ecs_type_kind_t : uint
 
         public const uint EcsTermMatchAnySrc = 2;
 
-        public const uint EcsTermNoData = 64;
-
         public const ulong EcsTermRefFlags = 18374686479671623680;
 
         public const uint EcsTermReflexive = 8;
@@ -12124,14 +12180,14 @@ public enum ecs_type_kind_t : uint
 
         public const int flecs_iter_cache_all = 255;
 
-        public const uint flecs_iter_cache_columns = 2;
-
         public const uint flecs_iter_cache_ids = 1;
 
         public const uint flecs_iter_cache_ptrs = 8;
 
         public const uint flecs_iter_cache_sources = 4;
 
+        public const uint flecs_iter_cache_trs = 2;
+
         public const uint flecs_iter_cache_variables = 16;
 
         public const int FLECS_QUERY_SCOPE_NESTING_MAX = 8;
@@ -12148,13 +12204,13 @@ public enum ecs_type_kind_t : uint
 
         public const int FLECS_VARIABLE_COUNT_MAX = 64;
 
-        public const string FLECS_VERSION = "4.0.0";
+        public const string FLECS_VERSION = "4.0.1";
 
         public const int FLECS_VERSION_MAJOR = 4;
 
         public const int FLECS_VERSION_MINOR = 0;
 
-        public const int FLECS_VERSION_PATCH = 0;
+        public const int FLECS_VERSION_PATCH = 1;
 
         private static void* ECS_AUTO_OVERRIDE_Ptr;
 
diff --git a/src/Flecs.NET.Codegen/Generators/IIterable.cs b/src/Flecs.NET.Codegen/Generators/IIterable.cs
index 01475e62..d6fd3aa2 100644
--- a/src/Flecs.NET.Codegen/Generators/IIterable.cs
+++ b/src/Flecs.NET.Codegen/Generators/IIterable.cs
@@ -103,6 +103,7 @@ public static string GenerateExtensions(Type type, int i)
             public {{Generator.GetInvokerReturnType(callback)}} {{Generator.GetInvokerName(callback)}}({{Generator.GetCallbackType(callback, i)}} callback)
             {
                 {{Generator.GetTypeName(Type.TypeHelper, i)}}.AssertReferenceTypes({{(Generator.GetCallbackIsUnmanaged(callback) ? "false" : "true")}});
+                {{Generator.GetTypeName(Type.TypeHelper, i)}}.AssertSparseTypes(Ecs.GetIterableWorld(ref this), {{(Generator.GetCallbackIsIter(callback) ? "false" : "true")}});
                 {{Generator.GetInvokerReturn(callback)}}Invoker.{{Generator.GetInvokerName(callback)}}(ref this, callback);
             }
         """);
diff --git a/src/Flecs.NET.Codegen/Generators/Invoker.cs b/src/Flecs.NET.Codegen/Generators/Invoker.cs
index b90556b8..85933c7e 100644
--- a/src/Flecs.NET.Codegen/Generators/Invoker.cs
+++ b/src/Flecs.NET.Codegen/Generators/Invoker.cs
@@ -1,3 +1,4 @@
+using System;
 using System.Collections.Generic;
 using System.Diagnostics.CodeAnalysis;
 using System.Linq;
@@ -43,7 +44,7 @@ private static string GenerateIterIteratorInvokers(int i)
             public static void Iter<{{Generator.TypeParameters[i]}}>(Iter it, {{Generator.GetCallbackType(callback, i)}} callback)
             {
                 Ecs.TableLock(it);
-                callback(it, {{Generator.GetCallbackArguments(i, callback)}});
+                callback(it, {{Generator.GetCallbackArguments(callback, i)}});
                 Ecs.TableUnlock(it);
             }
         """);
@@ -74,19 +75,45 @@ private static string GenerateEachIteratorInvokers(int i)
             {
                 {{Generator.GetCallbackCountVariable(callback)}}
                 
-                {{Generator.IterPointerVariables[i]}}
-                {{Generator.IterStepVariables[i]}}
+                {{Generator.FieldDataVariables[i]}}
+                IterationTechnique flags = it.GetIterationTechnique({{i + 1}});
                     
                 Ecs.TableLock(it);
-                    
-                for (int i = 0; i < count; i++, {{Generator.IterPointerIncrements[i]}})
-                    callback({{Generator.GetCallbackSteppedArguments(i, callback)}});
+                
+                if ({{Generator.ContainsReferenceTypes[i]}})
+                {
+                    if (flags == IterationTechnique.None)
+                        {{IterationTechnique.Managed}}(it, count, callback, {{Generator.FieldDataRefs[i]}});
+                    else if (flags == IterationTechnique.Shared)
+                        {{IterationTechnique.SharedManaged}}(it, count, callback, {{Generator.FieldDataRefs[i]}});
+                    else if (flags == IterationTechnique.Sparse)
+                        {{IterationTechnique.SparseManaged}}(it, count, callback, {{Generator.FieldDataRefs[i]}});
+                    else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                        {{IterationTechnique.SparseSharedManaged}}(it, count, callback, {{Generator.FieldDataRefs[i]}});
+                }
+                else
+                {
+                   if (flags == IterationTechnique.None)
+                        {{IterationTechnique.Unmanaged}}(it, count, callback, {{Generator.FieldDataRefs[i]}});
+                    else if (flags == IterationTechnique.Shared)
+                        {{IterationTechnique.SharedUnmanaged}}(it, count, callback, {{Generator.FieldDataRefs[i]}});
+                    else if (flags == IterationTechnique.Sparse)
+                        {{IterationTechnique.SparseUnmanaged}}(it, count, callback, {{Generator.FieldDataRefs[i]}});
+                    else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                        {{IterationTechnique.SparseSharedUnmanaged}}(it, count, callback, {{Generator.FieldDataRefs[i]}});
+                }
                     
                 Ecs.TableUnlock(it);
+                
+                return;
+                
+        {{GenerateEachInvokerIterators(callback, i)}}
             }
         """);
 
         return $$"""
+        using System;
+        using System.Runtime.CompilerServices;
         using Flecs.NET.Utilities;
         using static Flecs.NET.Bindings.flecs;
 
@@ -112,29 +139,47 @@ private static string GenerateFindIteratorInvokers(int i)
             {
                 {{Generator.GetCallbackCountVariable(callback)}}
                 
-                {{Generator.IterPointerVariables[i]}}
-                {{Generator.IterStepVariables[i]}}
+                {{Generator.FieldDataVariables[i]}}
+                IterationTechnique flags = it.GetIterationTechnique({{i + 1}});
                     
                 Ecs.TableLock(it);
                 
                 Entity result = default;
-                    
-                for (int i = 0; i < count; i++, {{Generator.IterPointerIncrements[i]}})
+                
+                if ({{Generator.ContainsReferenceTypes[i]}})
                 {
-                    if (!callback({{Generator.GetCallbackSteppedArguments(i, callback)}}))
-                        continue;
-                        
-                    result = new Entity(it.Handle->world, it.Handle->entities[i]);
-                    break;
+                    if (flags == IterationTechnique.None)
+                        result = {{IterationTechnique.Managed}}(it, count, callback, {{Generator.FieldDataRefs[i]}});
+                    else if (flags == IterationTechnique.Shared)
+                        result = {{IterationTechnique.SharedManaged}}(it, count, callback, {{Generator.FieldDataRefs[i]}});
+                    else if (flags == IterationTechnique.Sparse)
+                        result = {{IterationTechnique.SparseManaged}}(it, count, callback, {{Generator.FieldDataRefs[i]}});
+                    else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                        result = {{IterationTechnique.SparseSharedManaged}}(it, count, callback, {{Generator.FieldDataRefs[i]}});
+                }
+                else
+                {
+                   if (flags == IterationTechnique.None)
+                        result = {{IterationTechnique.Unmanaged}}(it, count, callback, {{Generator.FieldDataRefs[i]}});
+                    else if (flags == IterationTechnique.Shared)
+                        result = {{IterationTechnique.SharedUnmanaged}}(it, count, callback, {{Generator.FieldDataRefs[i]}});
+                    else if (flags == IterationTechnique.Sparse)
+                        result = {{IterationTechnique.SparseUnmanaged}}(it, count, callback, {{Generator.FieldDataRefs[i]}});
+                    else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                        result = {{IterationTechnique.SparseSharedUnmanaged}}(it, count, callback, {{Generator.FieldDataRefs[i]}});
                 }
                     
                 Ecs.TableUnlock(it);
                 
                 return result;
+                
+        {{GenerateFindInvokerIterators(callback, i)}}
             }
         """);
 
         return $$"""
+        using System;
+        using System.Runtime.CompilerServices;
         using Flecs.NET.Utilities;
         using static Flecs.NET.Bindings.flecs;
 
@@ -147,6 +192,39 @@ public static unsafe partial class Invoker
         """;
     }
 
+    private static string GenerateEachInvokerIterators(Callback callback, int i)
+    {
+        IEnumerable<string> invokerIterators = Enum.GetValues(typeof(IterationTechnique)).Cast<IterationTechnique>().Select((IterationTechnique iterationTechnique) => $$"""
+                [MethodImpl(MethodImplOptions.AggressiveInlining)]
+                static void {{iterationTechnique}}(Iter it, int count, {{Generator.GetCallbackType(callback, i)}} callback, {{Generator.FieldDataParameters[i]}})
+                {
+                    for (int i = 0; i < count; i++)
+                        callback({{Generator.GetCallbackArguments(callback, iterationTechnique, i)}});
+                }
+        """);
+
+        return string.Join(Separator.DoubleNewLine, invokerIterators);
+    }
+
+    private static string GenerateFindInvokerIterators(Callback callback, int i)
+    {
+        IEnumerable<string> invokerIterators = Enum.GetValues(typeof(IterationTechnique)).Cast<IterationTechnique>().Select((IterationTechnique iterationTechnique) => $$"""
+                [MethodImpl(MethodImplOptions.AggressiveInlining)]
+                static Entity {{iterationTechnique}}(Iter it, int count, {{Generator.GetCallbackType(callback, i)}} callback, {{Generator.FieldDataParameters[i]}})
+                {
+                    for (int i = 0; i < count; i++)
+                    {
+                        if (callback({{Generator.GetCallbackArguments(callback, iterationTechnique, i)}}))
+                            return new Entity(it.Handle->world, it.Handle->entities[i]);
+                    }
+                        
+                    return default;
+                }
+        """);
+
+        return string.Join(Separator.DoubleNewLine, invokerIterators);
+    }
+
     private static string GenerateIterIterableInvokers(int i)
     {
         IEnumerable<string> invokers = Generator.CallbacksIter.Select((Callback callback) => $$"""
@@ -279,7 +357,7 @@ public static string GenerateFetchComponentInvokers(int i)
                 bool hasComponents = Ecs.GetPointers<{{Generator.TypeParameters[i]}}>(world, entity, record, table, pointers);
 
                 if (hasComponents)
-                    callback({{Generator.GetCallbackArguments(i, callback)}});
+                    callback({{Generator.GetCallbackArguments(callback, i)}});
 
                 ecs_{{Generator.GetInvokerName(callback).ToLower()}}_end(record);
 
@@ -347,7 +425,7 @@ public static string GenerateFetchComponentInvokers(int i)
                     Ecs.EnsurePointers<{{Generator.TypeParameters[i]}}>(world, entity, pointers);
                 }
             
-                callback({{Generator.GetCallbackArguments(i, callback)}});
+                callback({{Generator.GetCallbackArguments(callback, i)}});
             
                 if (!world.IsDeferred())
                     Ecs.TableUnlock(world, table);
diff --git a/src/Flecs.NET.Codegen/Generators/IterIterable.cs b/src/Flecs.NET.Codegen/Generators/IterIterable.cs
index 2416d837..94e7139d 100644
--- a/src/Flecs.NET.Codegen/Generators/IterIterable.cs
+++ b/src/Flecs.NET.Codegen/Generators/IterIterable.cs
@@ -172,6 +172,9 @@ public override int GetHashCode()
         // IIterableBase Interface
         public unsafe partial struct {{Generator.GetTypeName(Type.IterIterable, i)}} : IIterableBase
         {
+            /// <inheritdoc cref="IterIterable.World"/>
+            public ref ecs_world_t* World => ref _iterIterable.World;
+            
             /// <inheritdoc cref="IterIterable.GetIter(ecs_world_t*)"/>
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public ecs_iter_t GetIter(ecs_world_t* world = null)
diff --git a/src/Flecs.NET.Codegen/Generators/NodeBuilder.cs b/src/Flecs.NET.Codegen/Generators/NodeBuilder.cs
index 584d2081..992a711c 100644
--- a/src/Flecs.NET.Codegen/Generators/NodeBuilder.cs
+++ b/src/Flecs.NET.Codegen/Generators/NodeBuilder.cs
@@ -17,6 +17,7 @@ public static string GenerateExtensions(Type builderType, Type returnType, int i
             public {{Generator.GetTypeName(returnType, i)}} {{Generator.GetInvokerName(callback)}}({{Generator.GetCallbackType(callback, i)}} callback)
             {
                 {{Generator.GetTypeName(Type.TypeHelper, i)}}.AssertReferenceTypes({{(Generator.GetCallbackIsUnmanaged(callback) ? "false" : "true")}});
+                {{Generator.GetTypeName(Type.TypeHelper, i)}}.AssertSparseTypes(World, {{(Generator.GetCallbackIsIter(callback) ? "false" : "true")}});
                 return {{(Generator.GetCallbackIsRun(callback) ? "SetRun" : "SetCallback")}}({{(Generator.GetCallbackIsDelegate(callback) ? string.Empty : "(IntPtr)")}}callback, Pointers<{{Generator.TypeParameters[i]}}>.{{callback}}).Build();
             }
         """);
diff --git a/src/Flecs.NET.Codegen/Generators/PageIterable.cs b/src/Flecs.NET.Codegen/Generators/PageIterable.cs
index 9a7c820d..c04bfd94 100644
--- a/src/Flecs.NET.Codegen/Generators/PageIterable.cs
+++ b/src/Flecs.NET.Codegen/Generators/PageIterable.cs
@@ -85,6 +85,9 @@ public override int GetHashCode()
         // IIterableBase Interface
         public unsafe partial struct {{Generator.GetTypeName(Type.PageIterable, i)}} : IIterableBase
         {
+            /// <inheritdoc cref="PageIterable.World"/>
+            public ref ecs_world_t* World => ref _pageIterable.World;
+        
             /// <inheritdoc cref="PageIterable.GetIter(ecs_world_t*)"/>
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public ecs_iter_t GetIter(ecs_world_t* world = null)
diff --git a/src/Flecs.NET.Codegen/Generators/Query.cs b/src/Flecs.NET.Codegen/Generators/Query.cs
index 76ba875d..c844ad31 100644
--- a/src/Flecs.NET.Codegen/Generators/Query.cs
+++ b/src/Flecs.NET.Codegen/Generators/Query.cs
@@ -221,6 +221,9 @@ public World RealWorld()
         // IIterableBase Interface
         public unsafe partial struct {{Generator.GetTypeName(Type.Query, i)}} : IIterableBase
         {
+            /// <inheritdoc cref="IIterableBase.World"/>
+            ref ecs_world_t* IIterableBase.World => ref Ecs.GetIterableWorld(ref _query);
+        
             /// <inheritdoc cref="Query.GetIter(ecs_world_t*)"/>
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public ecs_iter_t GetIter(ecs_world_t* world = null)
diff --git a/src/Flecs.NET.Codegen/Generators/TypeHelper.cs b/src/Flecs.NET.Codegen/Generators/TypeHelper.cs
index 548ab4b7..13a1699c 100644
--- a/src/Flecs.NET.Codegen/Generators/TypeHelper.cs
+++ b/src/Flecs.NET.Codegen/Generators/TypeHelper.cs
@@ -27,11 +27,14 @@ public static string GenerateTypeHelper(int i)
         using System.Diagnostics.CodeAnalysis;
         using System.Linq;
         using System.Runtime.CompilerServices;
+        using Flecs.NET.Utilities;
+        
+        using static Flecs.NET.Bindings.flecs;
         
         namespace Flecs.NET.Core;
         
         [SuppressMessage("ReSharper", "StaticMemberInGenericType")]
-        internal static partial class {{Generator.GetTypeName(Type.TypeHelper, i)}}
+        internal static unsafe partial class {{Generator.GetTypeName(Type.TypeHelper, i)}}
         {
             private static string[]? _typeNames;
             public static string[] TypeNames => _typeNames ??= [ {{Generator.TypeFullNames[i]}} ];
@@ -39,17 +42,20 @@ internal static partial class {{Generator.GetTypeName(Type.TypeHelper, i)}}
             public static readonly int Tags = {{Generator.Tags[i]}};
             public static readonly int ReferenceTypes = {{Generator.ReferenceTypes[i]}};
             
+            private static string GetTypeListString(int fields)
+            {
+                return string.Join(", ", Enumerable.Range(0, {{i + 1}})
+                    .Where(i => (fields & (1 << i)) != 0)
+                    .Select(i => TypeNames[i]));
+            }
+            
             [Conditional("DEBUG")]
             public static void AssertNoTags()
             {
                 if (Tags == 0)
                     return;
             
-                string tags = string.Join(", ", Enumerable.Range(0, {{i + 1}})
-                    .Where(i => (Tags & (1 << i)) != 0)
-                    .Select(i => TypeNames[i]));
-            
-                Ecs.Error($"Cannot use zero-sized structs as generic type arguments for this struct. Remove the following type arguments: {tags}");
+                Ecs.Error($"Cannot use zero-sized structs as generic type arguments for this struct. Remove the following type arguments: {GetTypeListString(Tags)}");
             }
             
             [Conditional("DEBUG")]
@@ -58,11 +64,21 @@ public static void AssertReferenceTypes(bool allowReferenceTypes)
                 if (allowReferenceTypes || ReferenceTypes == 0)
                     return;
             
-                string referenceTypes = string.Join(", ", Enumerable.Range(0, {{i + 1}})
-                    .Where(i => (ReferenceTypes & (1 << i)) != 0)
-                    .Select(i => TypeNames[i]));
+                Ecs.Error($"Cannot use managed types as generic type arguments for callback signatures that retrieve pointers or spans. Remove the following type arguments: {GetTypeListString(ReferenceTypes)}");
+            }
             
-                Ecs.Error($"Cannot use managed types as generic type arguments for callback signatures that retrieve pointers or spans. Remove the following type arguments: {referenceTypes}");
+            [Conditional("DEBUG")]
+            public static void AssertSparseTypes(ecs_world_t* world, bool allowSparseTypes)
+            {
+                if (allowSparseTypes)
+                    return;
+         
+                int sparseTypes = {{Generator.SparseBitField[i]}};
+         
+                if (sparseTypes == 0)
+                    return;
+         
+                Ecs.Error($"Cannot use sparse components as generic type arguments for this struct when using .Iter() to iterate because sparse fields must be obtained with Iter.FieldAt(). Use .Each()/.Run() to iterate or remove the following types from the list: {GetTypeListString(sparseTypes)}");
             }
         }
         """;
diff --git a/src/Flecs.NET.Codegen/Generators/WorkerIterable.cs b/src/Flecs.NET.Codegen/Generators/WorkerIterable.cs
index ee60c28b..9081e710 100644
--- a/src/Flecs.NET.Codegen/Generators/WorkerIterable.cs
+++ b/src/Flecs.NET.Codegen/Generators/WorkerIterable.cs
@@ -85,6 +85,9 @@ public override int GetHashCode()
         // IIterableBase Interface
         public unsafe partial struct {{Generator.GetTypeName(Type.WorkerIterable, i)}} : IIterableBase
         {
+            /// <inheritdoc cref="WorkerIterable.World"/>
+            public ref ecs_world_t* World => ref _workerIterable.World;
+            
             /// <inheritdoc cref="WorkerIterable.GetIter(ecs_world_t*)"/>
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public ecs_iter_t GetIter(ecs_world_t* world = null)
diff --git a/src/Flecs.NET.Codegen/Helpers/CallbackParameters.cs b/src/Flecs.NET.Codegen/Helpers/CallbackParameters.cs
new file mode 100644
index 00000000..755494e9
--- /dev/null
+++ b/src/Flecs.NET.Codegen/Helpers/CallbackParameters.cs
@@ -0,0 +1,15 @@
+namespace Flecs.NET.Codegen.Helpers;
+
+public enum CallbackParameters
+{
+    IterField,
+    IterSpan,
+    IterPointer,
+    EachRef,
+    EachEntityRef,
+    EachIterRef,
+    EachPointer,
+    EachEntityPointer,
+    EachIterPointer,
+    ReadRef
+}
diff --git a/src/Flecs.NET.Codegen/Helpers/Generator.cs b/src/Flecs.NET.Codegen/Helpers/Generator.cs
index 3414de51..388eb46b 100644
--- a/src/Flecs.NET.Codegen/Helpers/Generator.cs
+++ b/src/Flecs.NET.Codegen/Helpers/Generator.cs
@@ -12,111 +12,43 @@ public static class Generator
 
     #region Type Parameters
 
-    // Generates "T0, T1, T2, ..."
     public static readonly string[] TypeParameters = CacheJoinedStrings(Separator.Comma, i => $"T{i}");
-    // Generates "T0, T1, T2, ..."
-    public static readonly string[] TypeParametersUnderscored = CacheJoinedStrings(Separator.Comma, i => $"T_{i}");
-
-    // Generates "ref T0, ref T1, ref T2, ..."
     public static readonly string[] RefTypeParameters = CacheJoinedStrings(Separator.Comma, i => $"ref T{i}");
-
-    // Generates "Field<T0>, Field<T1>, Field<T2, ..."
     public static readonly string[] FieldTypeParameters = CacheJoinedStrings(Separator.Comma, i => $"Field<T{i}>");
-
-    // Generates "Span<T0>, Span<T1>, Span<T2, ..."
     public static readonly string[] SpanTypeParameters = CacheJoinedStrings(Separator.Comma, i => $"Span<T{i}>");
-
-    // Generates "T0*, T1*, T2*, ..."
     public static readonly string[] PointerTypeParameters = CacheJoinedStrings(Separator.Comma, i => $"T{i}*");
-
-    // Generates "T0 t0, T1 t1, T2 t2, ..."
-    public static readonly string[] Parameters = CacheJoinedStrings(Separator.Comma, i => $"T{i} t{i}");
-
-    // Generates "ref T0 t0, ref T1 t1, ref T2 t2, ..."
     public static readonly string[] RefParameters = CacheJoinedStrings(Separator.Comma, i => $"ref T{i} t{i}");
-
-    // Generates "Field<T0> t0, Field<T1> t1, Field<T2> t2, ..."
     public static readonly string[] FieldParameters = CacheJoinedStrings(Separator.Comma, i => $"Field<T{i}> t{i}");
-
-    // Generates "Span<T0> t0, Span<T1> t1, Span<T2> t2, ..."
     public static readonly string[] SpanParameters = CacheJoinedStrings(Separator.Comma, i => $"Span<T{i}> t{i}");
-
-    // Generates "T0* t0, T1* t1, T2* t2, ..."
     public static readonly string[] PointerParameters = CacheJoinedStrings(Separator.Comma, i => $"T{i}* t{i}");
-
-    // Generates "ref readonly t0, ref readonly T1 t1, ref readonly T2 t2, ..."
     public static readonly string[] RefReadOnlyParameters = CacheJoinedStrings(Separator.Comma, i => $"ref readonly T{i} t{i}");
 
-    // Generates "where T0 : unmanaged where T1 : unmanaged where T2 : unmanaged..."
-    public static readonly string[] TypeConstraints = CacheJoinedStrings(Separator.Space, i => $"where T{i} : unmanaged");
-
-    // Generates "where T0_ : unmanaged, T0 where T1_ : unmanaged, T1 where T2_ : unmanaged, T2..."
-    public static readonly string[] TypeConstraintsUnderScored = CacheJoinedStrings(Separator.Space, i => $"where T_{i} : unmanaged, T{i}");
-
     #endregion
 
     #region Callback Delegates
 
     public const string RunCallbackDelegate = "Ecs.RunCallback";
 
-    public const string IterCallbackDelegate = "Ecs.IterCallback";
-
-    public const string EachEntityCallbackDelegate = "Ecs.EachEntityCallback";
-
-    public const string EachIterCallbackDelegate = "Ecs.EachIterCallback";
-
-    // Generates "Ecs.IterFieldCallback<T0, T1, T2, ...>"
     public static readonly string[] IterFieldCallbackDelegate = CacheStrings(i => $"Ecs.IterFieldCallback<{TypeParameters[i]}>");
-
-    // Generates "Ecs.IterSpanCallback<T0, T1, T2, ...>"
     public static readonly string[] IterSpanCallbackDelegate = CacheStrings(i => $"Ecs.IterSpanCallback<{TypeParameters[i]}>");
-
-    // Generates "Ecs.IterPointerCallback<T0, T1, T2, ...>"
     public static readonly string[] IterPointerCallbackDelegate = CacheStrings(i => $"Ecs.IterPointerCallback<{TypeParameters[i]}>");
 
-    // Generates "Ecs.EachRefCallback<T0, T1, T2, ...>"
     public static readonly string[] EachRefCallbackDelegate = CacheStrings(i => $"Ecs.EachRefCallback<{TypeParameters[i]}>");
-
-    // Generates "Ecs.EachEntityRefCallback<T0, T1, T2, ...>"
     public static readonly string[] EachEntityRefCallbackDelegate = CacheStrings(i => $"Ecs.EachEntityRefCallback<{TypeParameters[i]}>");
-
-    // Generates "Ecs.EachIterRefCallback<T0, T1, T2, ...>"
     public static readonly string[] EachIterRefCallbackDelegate = CacheStrings(i => $"Ecs.EachIterRefCallback<{TypeParameters[i]}>");
-
-    // Generates "Ecs.EachPointerCallback<T0, T1, T2, ...>"
     public static readonly string[] EachPointerCallbackDelegate = CacheStrings(i => $"Ecs.EachPointerCallback<{TypeParameters[i]}>");
-
-    // Generates "Ecs.EachEntityPointerCallback<T0, T1, T2, ...>"
     public static readonly string[] EachEntityPointerCallbackDelegate = CacheStrings(i => $"Ecs.EachEntityPointerCallback<{TypeParameters[i]}>");
-
-    // Generates "Ecs.EachIterPointerCallback<T0, T1, T2, ...>"
     public static readonly string[] EachIterPointerCallbackDelegate = CacheStrings(i => $"Ecs.EachIterPointerCallback<{TypeParameters[i]}>");
 
-    // Generates "Ecs.FindRefCallback<T0, T1, T2, ...>"
     public static readonly string[] FindRefCallbackDelegate = CacheStrings(i => $"Ecs.FindRefCallback<{TypeParameters[i]}>");
-
-    // Generates "Ecs.FindEntityRefCallback<T0, T1, T2, ...>"
     public static readonly string[] FindEntityRefCallbackDelegate = CacheStrings(i => $"Ecs.FindEntityRefCallback<{TypeParameters[i]}>");
-
-    // Generates "Ecs.FindIterRefCallback<T0, T1, T2, ...>"
     public static readonly string[] FindIterRefCallbackDelegate = CacheStrings(i => $"Ecs.FindIterRefCallback<{TypeParameters[i]}>");
-
-    // Generates "Ecs.FindPointerCallback<T0, T1, T2, ...>"
     public static readonly string[] FindPointerCallbackDelegate = CacheStrings(i => $"Ecs.FindPointerCallback<{TypeParameters[i]}>");
-
-    // Generates "Ecs.FindEntityPointerCallback<T0, T1, T2, ...>"
     public static readonly string[] FindEntityPointerCallbackDelegate = CacheStrings(i => $"Ecs.FindEntityPointerCallback<{TypeParameters[i]}>");
-
-    // Generates "Ecs.FindIterPointerCallback<T0, T1, T2, ...>"
     public static readonly string[] FindIterPointerCallbackDelegate = CacheStrings(i => $"Ecs.FindIterPointerCallback<{TypeParameters[i]}>");
 
-    // Generates "Ecs.ReadRefCallback<T0, T1, T2, ...>"
     public static readonly string[] ReadRefCallbackDelegate = CacheStrings(i => $"Ecs.ReadRefCallback<{TypeParameters[i]}>");
-
-    // Generates "Ecs.WriteRefCallback<T0, T1, T2, ...>"
     public static readonly string[] WriteRefCallbackDelegate = CacheStrings(i => $"Ecs.WriteRefCallback<{TypeParameters[i]}>");
-
-    // Generates "Ecs.InsertRefCallback<T0, T1, T2, ...>"
     public static readonly string[] InsertRefCallbackDelegate = CacheStrings(i => $"Ecs.InsertRefCallback<{TypeParameters[i]}>");
 
     #endregion
@@ -125,120 +57,40 @@ public static class Generator
 
     public const string RunCallbackPointer = "delegate*<Iter, void>";
 
-    public const string IterCallbackPointer = "delegate*<Iter, void>";
-
-    public const string EachEntityCallbackPointer = "delegate*<Entity, void>";
-
-    public const string EachIterCallbackPointer = "delegate*<Iter, int, void>";
-
-    // Generates "delegate*<Iter, Field<T0>, Field<T1>, Field<T2>, void>"
     public static readonly string[] IterFieldCallbackPointer = CacheStrings(i => $"delegate*<Iter, {FieldTypeParameters[i]}, void>");
-
-    // Generates "delegate*<Iter, Span<T0>, Span<T1>, Span<T2>, void>"
     public static readonly string[] IterSpanCallbackPointer = CacheStrings(i => $"delegate*<Iter, {SpanTypeParameters[i]}, void>");
-
-    // Generates "delegate*<Iter, T0*, T1*, T2*, void>"
     public static readonly string[] IterPointerCallbackPointer = CacheStrings(i => $"delegate*<Iter, {PointerTypeParameters[i]}, void>");
 
-    // Generates "delegate*<ref T0, ref T1, ref T2, void>"
     public static readonly string[] EachRefCallbackPointer = CacheStrings(i => $"delegate*<{RefTypeParameters[i]}, void>");
-
-    // Generates "delegate*<Entity, ref T0, ref T1, ref T2, void>"
     public static readonly string[] EachEntityRefCallbackPointer = CacheStrings(i => $"delegate*<Entity, {RefTypeParameters[i]}, void>");
-
-    // Generates "delegate*<Iter, int, ref T0, ref T1, ref T2, void>"
     public static readonly string[] EachIterRefCallbackPointer = CacheStrings(i => $"delegate*<Iter, int, {RefTypeParameters[i]}, void>");
-
-    // Generates "delegate*<T0*, T1*, T2*, void>"
     public static readonly string[] EachPointerCallbackPointer = CacheStrings(i => $"delegate*<{PointerTypeParameters[i]}, void>");
-
-    // Generates "delegate*<Entity, T0*, T1*, T2*, void>"
     public static readonly string[] EachEntityPointerCallbackPointer = CacheStrings(i => $"delegate*<Entity, {PointerTypeParameters[i]}, void>");
-
-    // Generates "delegate*<Iter, int, T0*, T1*, T2*, void>"
     public static readonly string[] EachIterPointerCallbackPointer = CacheStrings(i => $"delegate*<Iter, int, {PointerTypeParameters[i]}, void>");
 
-    // Generates "delegate*<ref T0, ref T1, ref T2, bool>"
     public static readonly string[] FindRefCallbackPointer = CacheStrings(i => $"delegate*<{RefTypeParameters[i]}, bool>");
-
-    // Generates "delegate*<Entity, ref T0, ref T1, ref T2, bool>"
     public static readonly string[] FindEntityRefCallbackPointer = CacheStrings(i => $"delegate*<Entity, {RefTypeParameters[i]}, bool>");
-
-    // Generates "delegate*<Iter, int, ref T0, ref T1, ref T2, bool>"
     public static readonly string[] FindIterRefCallbackPointer = CacheStrings(i => $"delegate*<Iter, int, {RefTypeParameters[i]}, bool>");
-
-    // Generates "delegate*<T0*, T1*, T2*, bool>"
     public static readonly string[] FindPointerCallbackPointer = CacheStrings(i => $"delegate*<{PointerTypeParameters[i]}, bool>");
-
-    // Generates "delegate*<Entity, T0*, T1*, T2*, bool>"
     public static readonly string[] FindEntityPointerCallbackPointer = CacheStrings(i => $"delegate*<Entity, {PointerTypeParameters[i]}, bool>");
-
-    // Generates "delegate*<Iter, int, T0*, T1*, T2*, bool>"
     public static readonly string[] FindIterPointerCallbackPointer = CacheStrings(i => $"delegate*<Iter, int, {PointerTypeParameters[i]}, bool>");
 
     #endregion
 
     #region Invoker
 
-    // Generates "byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1);..."
-    public static readonly string[] IterPointerVariables = CacheJoinedStrings(Separator.Space, i => $"byte* pointer{i} = (byte*)it.GetPointer<T{i}>({i});");
-
-    // Generates "int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1);..."
-    public static readonly string[] IterStepVariables = CacheJoinedStrings(Separator.Space, i => $"int step{i} = it.Step<T{i}>({i});");
-
-    // Generates "pointer0 = &pointer0[step0], pointer1 = &pointer1[step1]..."
-    public static readonly string[] IterPointerIncrements = CacheJoinedStrings(Separator.Comma, i => $"pointer{i} = &pointer{i}[step{i}]");
+    public static readonly string[] FieldDataVariables = CacheJoinedStrings(Separator.Space, i => $"FieldData<T{i}> field{i} = it.GetFieldData<T{i}>({i});");
+    public static readonly string[] FieldDataParameters = CacheJoinedStrings(Separator.Comma, i => $"ref FieldData<T{i}> field{i}");
+    public static readonly string[] FieldDataRefs = CacheJoinedStrings(Separator.Comma, i => $"ref field{i}");
 
     #endregion
 
     #region Invoker Callback Arguments
 
-    // Generates "it.Field<T0>(0), it.Field<T1>(1), it.Field<T2>(2)..."
     public static readonly string[] IterFieldArguments = CacheJoinedStrings(Separator.Comma, i => $"it.Field<T{i}>({i})");
-
-    // Generates "it.GetSpan<T0>(0), it.GetSpan<T1>(1), it.GetSpan<T2>(2)..."
     public static readonly string[] IterSpanArguments = CacheJoinedStrings(Separator.Comma, i => $"it.GetSpan<T{i}>({i})");
-
-    // Generates "it.GetPointer<T0>(0), it.GetPointer<T1>(1), it.GetPointer<T2>(2)..."
     public static readonly string[] IterPointerArguments = CacheJoinedStrings(Separator.Comma, i => $"it.GetPointer<T{i}>({i})");
 
-    // Generates "ref Managed.GetTypeRef<T0>(&pointer0[i]), ref Managed.GetTypeRef<T1>(&pointer1[i]), ref Managed.GetTypeRef<T2>(&pointer2[i])..."
-    public static readonly string[] EachRefArguments = CacheJoinedStrings(Separator.Comma, i => $"ref Managed.GetTypeRef<T{i}>(&pointer{i}[i])");
-
-    // Generates "new Entity(it.Handle->world, it.Handle->entities[i]), ref Managed.GetTypeRef<T0>(&pointer0[i]), ref Managed.GetTypeRef<T1>(&pointer1[i]), ref Managed.GetTypeRef<T2>(&pointer2[i])"
-    public static readonly string[] EachEntityRefArguments = CacheStrings(i => $"new Entity(it.Handle->world, it.Handle->entities[i]), {EachRefArguments[i]}");
-
-    // Generates "it, i, ref Managed.GetTypeRef<T0>(&pointer0[i]), ref Managed.GetTypeRef<T1>(&pointer1[i]), ref Managed.GetTypeRef<T2>(&pointer2[i])"
-    public static readonly string[] EachIterRefArguments = CacheStrings(i => $"it, i, {EachRefArguments[i]}");
-
-    // Generates "&pointer0[i], &pointer1[i], &pointer2[i]..."
-    public static readonly string[] EachPointerArguments = CacheJoinedStrings(Separator.Comma, i => $"&pointer{i}[i]");
-
-    // Generates "new Entity(it.Handle->world, it.Handle->entities[i]), pointer0[i], &pointer1[i], &pointer2[i]"
-    public static readonly string[] EachEntityPointerArguments = CacheStrings(i => $"new Entity(it.Handle->world, it.Handle->entities[i]), {EachPointerArguments[i]}");
-
-    // Generates "it, i, pointer0[i], &pointer1[i], &pointer2[i]"
-    public static readonly string[] EachIterPointerArguments = CacheStrings(i => $"it, i, {EachPointerArguments[i]}");
-
-    // Generates "ref Managed.GetTypeRef<T0>(&pointer0[i * step0]), ref Managed.GetTypeRef<T1>(&pointer1[i * step1]), ref Managed.GetTypeRef<T2>(&pointer2[i * step2])..."
-    public static readonly string[] EachRefSteppedArguments = CacheJoinedStrings(Separator.Comma, i => $"ref Managed.GetTypeRef<T{i}>(pointer{i})");
-
-    // Generates "new Entity(it.Handle->world, it.Handle->entities[i]), ref Managed.GetTypeRef<T0>(&pointer0[i * step0]), ref Managed.GetTypeRef<T1>(&pointer1[i * step1]), ref Managed.GetTypeRef<T2>(&pointer2[i * step2])"
-    public static readonly string[] EachEntityRefSteppedArguments = CacheStrings(i => $"new Entity(it.Handle->world, it.Handle->entities[i]), {EachRefSteppedArguments[i]}");
-
-    // Generates "it, i, ref Managed.GetTypeRef<T0>(&pointer0[i * step0]), ref Managed.GetTypeRef<T1>(&pointer1[i * step1]), ref Managed.GetTypeRef<T2>(&pointer2[i * step2])"
-    public static readonly string[] EachIterRefSteppedArguments = CacheStrings(i => $"it, i, {EachRefSteppedArguments[i]}");
-
-    // Generates "&pointer0[i * step0], &pointer1[i * step1], &pointer2[i * step2]..."
-    public static readonly string[] EachPointerSteppedArguments = CacheJoinedStrings(Separator.Comma, i => $"(T{i}*)pointer{i}");
-
-    // Generates "new Entity(it.Handle->world, it.Handle->entities[i]), &pointer0[i * step0], &pointer1[i * step1], &pointer2[i * step2]..."
-    public static readonly string[] EachEntityPointerSteppedArguments = CacheStrings(i => $"new Entity(it.Handle->world, it.Handle->entities[i]), {EachPointerSteppedArguments[i]}");
-
-    // Generates "it, i, &pointer0[i * step0], &pointer1[i * step1], &pointer2[i * step2]..."
-    public static readonly string[] EachIterPointerSteppedArguments = CacheStrings(i => $"it, i, {EachPointerSteppedArguments[i]}");
-
-    // Generates "ref Managed.GetTypeRef<T0>(&pointers[0]), ref Managed.GetTypeRef<T0>(&pointers[0])"
     public static readonly string[] ReadRefArguments = CacheJoinedStrings(Separator.Comma, i => $"ref Managed.GetTypeRef<T{i}>(pointers[{i}])");
     public static readonly string[] WriteRefArguments = ReadRefArguments;
     public static readonly string[] InsertRefArguments = ReadRefArguments;
@@ -247,45 +99,38 @@ public static class Generator
 
     #region Entity Component Callbacks
 
-    // Generates "Type<T0>.Id(world), Type<T1>.Id(world), Type<T2>.Id(world)..."
     public static readonly string[] TypeIdList = CacheJoinedStrings(Separator.Comma, i => $"Type<T{i}>.Id(world)");
 
-    // Generates "ecs_table_get_column_index(realWorld, table, ids[0]), ecs_table_get_column_index(realWorld, table, ids[1])..."
     public static readonly string[] ColumnList = CacheJoinedStrings(Separator.Comma, i => $"ecs_table_get_column_index(realWorld, table, ids[{i}])");
 
-    // Generates "ulong* ids = stackalloc ulong[] { Type<T0>.Id(world), Type<T1>.Id(world) };"
     public static readonly string[] IdsArray = CacheStrings(i => $"ulong* ids = stackalloc ulong[] {{ {TypeIdList[i]} }};");
 
-    // Generates "int* columns = stackalloc int[] { ecs_table_get_column_index(realWorld, table, ids[0]), ecs_table_get_column_index(realWorld, table, ids[1]) };"
     public static readonly string[] ColumnsArray = CacheStrings(i => $"int* columns = stackalloc int[] {{ {ColumnList[i]} }};");
 
-    // Generates "ptrs[0] = ecs_ensure_id(world, e, Type<T0>.Id(world)); ptrs[1] = ecs_ensure_id(world, e, Type<T1>.Id(world));"
     public static readonly string[] EnsurePointers = CacheJoinedStrings(Separator.Space, i => $"ptrs[{i}] = ecs_ensure_id(world, e, Type<T{i}>.Id(world));");
 
-    // Generates "ecs_modified_id(world, id, ids[0]); ecs_modified_id(world, id, ids[1]);..."
     public static readonly string[] ModifiedChain = CacheJoinedStrings(Separator.Space, i => $"ecs_modified_id(world, entity, ids[{i}]);");
 
     #endregion
 
     #region Type Helpers
 
-    // Generates "(Type<T0>.IsTag ? 1 << 0 : 0) | (Type<T1>.IsTag ? 1 << 1 : 0)..."
     public static readonly string[] Tags = CacheJoinedStrings(Separator.BitwiseOr, i => $"(Type<T{i}>.IsTag ? 1 << {i} : 0)");
 
-    // Generates "(RuntimeHelpers.IsReferenceOrContainsReferences<T0>() ? 1 << 0 : 0) | (RuntimeHelpers.IsReferenceOrContainsReferences<T1>() ? 1 << 1 : 0)..."
     public static readonly string[] ReferenceTypes = CacheJoinedStrings(Separator.BitwiseOr, i => $"(RuntimeHelpers.IsReferenceOrContainsReferences<T{i}>() ? 1 << {i} : 0)");
 
-    // Generates "Type<T0>.FullName, Type<T1>.Fullname..."
     public static readonly string[] TypeFullNames = CacheJoinedStrings(Separator.Comma, i => $"Type<T{i}>.FullName");
 
+    public static readonly string[] SparseBitField = CacheJoinedStrings(Separator.BitwiseOr, i => $"(ecs_has_id(world, Type<T{i}>.Id(world), Ecs.Sparse) == Utils.True ? 1 << {i} : 0)");
+
+    public static readonly string[] ContainsReferenceTypes = CacheJoinedStrings(Separator.Or, i => $"RuntimeHelpers.IsReferenceOrContainsReferences<T{i}>()");
+
     #endregion
 
     #region Misc
 
-    // Generates ".With<T0>.With<T1>().With<T2>()..."
     public static readonly string[] WithChain = CacheJoinedStrings(Separator.None, i => $".With<T{i}>()");
 
-    // Generates "<typeparam name="T0">The T0 component type.</typeparam> <typeparam name="T1">The T1 component type.</typeparam> <typeparam name="T2">The T2 component type.</typeparam>..."
     public static readonly string[] XmlTypeParameters = CacheJoinedStrings(Separator.Space, i => $"<typeparam name=\"T{i}\">The T{i} component type.</typeparam>");
 
     #endregion
@@ -547,38 +392,115 @@ Callback.FindEntityPointerCallbackPointer or
         };
     }
 
-    public static string GetCallbackArguments(int i, Callback callback)
+    public static bool GetCallbackIsIter(Callback callback)
     {
         return callback switch
         {
-            Callback.IterFieldCallbackDelegate or Callback.IterFieldCallbackPointer => IterFieldArguments[i],
-            Callback.IterSpanCallbackDelegate or Callback.IterSpanCallbackPointer => IterSpanArguments[i],
-            Callback.IterPointerCallbackDelegate or Callback.IterPointerCallbackPointer => IterPointerArguments[i],
-            Callback.EachRefCallbackDelegate or Callback.EachRefCallbackPointer or Callback.FindRefCallbackDelegate or Callback.FindRefCallbackPointer => EachRefArguments[i],
-            Callback.EachEntityRefCallbackDelegate or Callback.EachEntityRefCallbackPointer or Callback.FindEntityRefCallbackDelegate or Callback.FindEntityRefCallbackPointer => EachEntityRefArguments[i],
-            Callback.EachIterRefCallbackDelegate or Callback.EachIterRefCallbackPointer or Callback.FindIterRefCallbackDelegate or Callback.FindIterRefCallbackPointer => EachIterRefArguments[i],
-            Callback.EachPointerCallbackDelegate or Callback.EachPointerCallbackPointer or Callback.FindPointerCallbackDelegate or Callback.FindPointerCallbackPointer => EachPointerArguments[i],
-            Callback.EachEntityPointerCallbackDelegate or Callback.EachEntityPointerCallbackPointer or Callback.FindEntityPointerCallbackDelegate or Callback.FindEntityPointerCallbackPointer => EachEntityPointerArguments[i],
-            Callback.EachIterPointerCallbackDelegate or Callback.EachIterPointerCallbackPointer or Callback.FindIterPointerCallbackDelegate or Callback.FindIterPointerCallbackPointer => EachIterPointerArguments[i],
-            Callback.ReadRefCallbackDelegate or Callback.WriteRefCallbackDelegate or Callback.InsertRefCallbackDelegate => ReadRefArguments[i],
-            _ => throw new ArgumentOutOfRangeException(nameof(callback), callback, null)
+            Callback.IterFieldCallbackDelegate or
+            Callback.IterFieldCallbackPointer or
+            Callback.IterSpanCallbackDelegate or
+            Callback.IterSpanCallbackPointer or
+            Callback.IterPointerCallbackDelegate or
+            Callback.IterPointerCallbackPointer => true,
+            _ => false
         };
     }
 
-    public static string GetCallbackSteppedArguments(int i, Callback callback)
+    public static CallbackParameters GetCallbackParameters(Callback callback)
     {
         return callback switch
         {
-            Callback.EachRefCallbackDelegate or Callback.EachRefCallbackPointer or Callback.FindRefCallbackDelegate or Callback.FindRefCallbackPointer => EachRefSteppedArguments[i],
-            Callback.EachEntityRefCallbackDelegate or Callback.EachEntityRefCallbackPointer or Callback.FindEntityRefCallbackDelegate or Callback.FindEntityRefCallbackPointer => EachEntityRefSteppedArguments[i],
-            Callback.EachIterRefCallbackDelegate or Callback.EachIterRefCallbackPointer or Callback.FindIterRefCallbackDelegate or Callback.FindIterRefCallbackPointer => EachIterRefSteppedArguments[i],
-            Callback.EachPointerCallbackDelegate or Callback.EachPointerCallbackPointer or Callback.FindPointerCallbackDelegate or Callback.FindPointerCallbackPointer => EachPointerSteppedArguments[i],
-            Callback.EachEntityPointerCallbackDelegate or Callback.EachEntityPointerCallbackPointer or Callback.FindEntityPointerCallbackDelegate or Callback.FindEntityPointerCallbackPointer => EachEntityPointerSteppedArguments[i],
-            Callback.EachIterPointerCallbackDelegate or Callback.EachIterPointerCallbackPointer or Callback.FindIterPointerCallbackDelegate or Callback.FindIterPointerCallbackPointer => EachIterPointerSteppedArguments[i],
+            Callback.IterFieldCallbackDelegate or
+            Callback.IterFieldCallbackPointer => CallbackParameters.IterField,
+
+            Callback.IterSpanCallbackDelegate or
+            Callback.IterSpanCallbackPointer =>  CallbackParameters.IterSpan,
+
+            Callback.IterPointerCallbackDelegate or
+            Callback.IterPointerCallbackPointer =>  CallbackParameters.IterPointer,
+
+            Callback.EachRefCallbackDelegate or
+            Callback.EachRefCallbackPointer or
+            Callback.FindRefCallbackDelegate or
+            Callback.FindRefCallbackPointer => CallbackParameters.EachRef,
+
+            Callback.EachEntityRefCallbackDelegate or
+            Callback.EachEntityRefCallbackPointer or
+            Callback.FindEntityRefCallbackDelegate or
+            Callback.FindEntityRefCallbackPointer => CallbackParameters.EachEntityRef,
+
+            Callback.EachIterRefCallbackDelegate or
+            Callback.EachIterRefCallbackPointer or
+            Callback.FindIterRefCallbackDelegate or
+            Callback.FindIterRefCallbackPointer => CallbackParameters.EachIterRef,
+
+            Callback.EachPointerCallbackDelegate or
+            Callback.EachPointerCallbackPointer or
+            Callback.FindPointerCallbackDelegate or
+            Callback.FindPointerCallbackPointer => CallbackParameters.EachPointer,
+
+            Callback.EachEntityPointerCallbackDelegate or
+            Callback.EachEntityPointerCallbackPointer or
+            Callback.FindEntityPointerCallbackDelegate or
+            Callback.FindEntityPointerCallbackPointer => CallbackParameters.EachEntityPointer,
+
+            Callback.EachIterPointerCallbackDelegate or
+            Callback.EachIterPointerCallbackPointer or
+            Callback.FindIterPointerCallbackDelegate or
+            Callback.FindIterPointerCallbackPointer => CallbackParameters.EachIterPointer,
+
+            Callback.ReadRefCallbackDelegate or
+            Callback.WriteRefCallbackDelegate or
+            Callback.InsertRefCallbackDelegate => CallbackParameters.ReadRef,
+
             _ => throw new ArgumentOutOfRangeException(nameof(callback), callback, null)
         };
     }
 
+    public static string GetCallbackArguments(Callback callback, int i)
+    {
+        return GetCallbackParameters(callback) switch
+        {
+            CallbackParameters.IterField => IterFieldArguments[i],
+            CallbackParameters.IterSpan => IterSpanArguments[i],
+            CallbackParameters.IterPointer => IterPointerArguments[i],
+            CallbackParameters.ReadRef => ReadRefArguments[i],
+            _ => throw new ArgumentOutOfRangeException(nameof(callback))
+        };
+    }
+
+    public static string GetCallbackArguments(Callback parameters, IterationTechnique iterationTechnique, int i)
+    {
+        return GetCallbackParameters(parameters) switch
+        {
+            CallbackParameters.EachRef => $"{GetEachRefArguments(iterationTechnique, i)}",
+            CallbackParameters.EachPointer => $"{GetEachPointerArguments(iterationTechnique, i)}",
+            CallbackParameters.EachEntityRef => $"new Entity(it.Handle->world, it.Handle->entities[i]), {GetEachRefArguments(iterationTechnique, i)}",
+            CallbackParameters.EachEntityPointer => $"new Entity(it.Handle->world, it.Handle->entities[i]), {GetEachPointerArguments(iterationTechnique, i)}",
+            CallbackParameters.EachIterRef => $"it, i, {GetEachRefArguments(iterationTechnique, i)}",
+            CallbackParameters.EachIterPointer => $"it, i, {GetEachPointerArguments(iterationTechnique, i)}",
+            _ => throw new ArgumentOutOfRangeException(nameof(parameters), parameters, null)
+        };
+    }
+
+    public static readonly string[][] EachPointerArguments = typeof(IterationTechnique).GetEnumNames()
+        .Select((str) => CacheJoinedStrings(Separator.Comma, i => $"field{i}.Pointer{str}(i)"))
+        .ToArray();
+
+    public static readonly string[][] EachRefArguments = typeof(IterationTechnique).GetEnumNames()
+        .Select((str) => CacheJoinedStrings(Separator.Comma, i => $"ref field{i}.Ref{str}(i)"))
+        .ToArray();
+
+    public static string GetEachPointerArguments(IterationTechnique type, int i)
+    {
+        return EachPointerArguments[(int)type][i];
+    }
+
+    public static string GetEachRefArguments(IterationTechnique type, int i)
+    {
+        return EachRefArguments[(int)type][i];
+    }
+
     public static string GetCallbackCountVariable(Callback callback)
     {
         return callback switch
diff --git a/src/Flecs.NET.Codegen/Helpers/IterationTechnique.cs b/src/Flecs.NET.Codegen/Helpers/IterationTechnique.cs
new file mode 100644
index 00000000..b6a53024
--- /dev/null
+++ b/src/Flecs.NET.Codegen/Helpers/IterationTechnique.cs
@@ -0,0 +1,14 @@
+namespace Flecs.NET.Codegen.Helpers;
+
+public enum IterationTechnique
+{
+    Unmanaged,
+    SharedUnmanaged,
+    SparseUnmanaged,
+    SparseSharedUnmanaged,
+
+    Managed,
+    SharedManaged,
+    SparseManaged,
+    SparseSharedManaged
+}
diff --git a/src/Flecs.NET.Codegen/Helpers/Separator.cs b/src/Flecs.NET.Codegen/Helpers/Separator.cs
index aecaee5f..55af70db 100644
--- a/src/Flecs.NET.Codegen/Helpers/Separator.cs
+++ b/src/Flecs.NET.Codegen/Helpers/Separator.cs
@@ -7,6 +7,7 @@ public static class Separator
     public const string Space = " ";
     public const string NewLine = "\n";
     public const string DoubleNewLine = "\n\n";
+    public const string And = " && ";
     public const string Or = " || ";
     public const string BitwiseOr = " | ";
 }
diff --git a/src/Flecs.NET.Examples/Observers/YieldExisting.cs b/src/Flecs.NET.Examples/Observers/YieldExisting.cs
index 0a849cb0..ff2e274a 100644
--- a/src/Flecs.NET.Examples/Observers/YieldExisting.cs
+++ b/src/Flecs.NET.Examples/Observers/YieldExisting.cs
@@ -1,9 +1,6 @@
 // Observers can enable a "YieldExisting" feature that upon creation of the
 // observer produces events for all entities that match the observer query. The
 // feature is only implemented for the builtin EcsOnAdd and EcsOnSet events.
-//
-// Custom events can also implement behavior for YieldExisting by adding the
-// Iterable component to the event (see EcsIterable for more details).
 
 using Flecs.NET.Core;
 
diff --git a/src/Flecs.NET.Native/Flecs.NET.Native.csproj b/src/Flecs.NET.Native/Flecs.NET.Native.csproj
index 5346c0cb..7668c50d 100644
--- a/src/Flecs.NET.Native/Flecs.NET.Native.csproj
+++ b/src/Flecs.NET.Native/Flecs.NET.Native.csproj
@@ -10,7 +10,7 @@
         <IncludeContentInPack>true</IncludeContentInPack>
         <IncludeBuildOutput>false</IncludeBuildOutput>
 
-        <Version>4.0.0</Version>
+        <Version>4.0.1</Version>
         <Title Condition="'$(Configuration)' == 'Debug'">Flecs.NET.Native.Debug</Title>
         <Title Condition="'$(Configuration)' == 'Release'">Flecs.NET.Native.Release</Title>
         <Authors>BeanCheeseBurrito</Authors>
diff --git a/src/Flecs.NET.Native/build.zig b/src/Flecs.NET.Native/build.zig
index f109527a..97be1b05 100644
--- a/src/Flecs.NET.Native/build.zig
+++ b/src/Flecs.NET.Native/build.zig
@@ -20,7 +20,7 @@ pub fn compileFlecs(options: anytype, b: *Build, lib_type: LibType) void {
     };
 
     lib.linkLibC();
-    lib.addCSourceFile(.{ .file = b.path("../../submodules/flecs/flecs.c"), .flags = &.{} });
+    lib.addCSourceFile(.{ .file = b.path("../../submodules/flecs/flecs.c"), .flags = &.{"-fno-sanitize=undefined"} });
     lib.defineCMacro(if (options.optimize == .Debug) "FLECS_DEBUG" else "FLECS_NDEBUG", null);
 
     if (options.soft_assert) {
diff --git a/src/Flecs.NET.Tests/CSharp/Core/QueryTests.cs b/src/Flecs.NET.Tests/CSharp/Core/QueryTests.cs
index bcffc7e6..0d619519 100644
--- a/src/Flecs.NET.Tests/CSharp/Core/QueryTests.cs
+++ b/src/Flecs.NET.Tests/CSharp/Core/QueryTests.cs
@@ -798,7 +798,7 @@ private void EachManagedClass()
             Assert.True(query.IsTrue());
             Assert.Equal(5, query.Count());
 
-            query.Each(static (Iter _, int i, ref ManagedClass component) =>
+            query.Each(static (Iter _, int _, ref ManagedClass component) =>
             {
                 Assert.Equal(10, component.Value);
             });
@@ -816,10 +816,178 @@ private void EachManagedStruct()
             Assert.True(query.IsTrue());
             Assert.Equal(5, query.Count());
 
-            query.Each(static (Iter it, int i, ref ManagedStruct component) =>
+            query.Each(static (Iter _, int _, ref ManagedStruct component) =>
             {
                 Assert.Equal(10, component.Value);
             });
         }
+
+        [Fact]
+        private void EachSharedUnmanaged()
+        {
+            using World world = World.Create();
+
+            world.Component<SharedComponent>().Entity.Add(Ecs.OnInstantiate, Ecs.Inherit);
+
+            using Query<UnmanagedComponent, SharedComponent> query = world.Query<UnmanagedComponent, SharedComponent>();
+
+            Entity prefab = world.Prefab()
+                .Set(new UnmanagedComponent(10))
+                .Set(new SharedComponent(20));
+
+            for (int i = 0; i < 5; i++)
+                world.Entity().IsA(prefab);
+
+            Assert.True(query.IsTrue());
+            Assert.Equal(5, query.Count());
+
+            query.Each(static (Iter it, int _, ref UnmanagedComponent c1, ref SharedComponent c2) =>
+            {
+                Assert.Equal(IterationTechnique.Shared, it.GetIterationTechnique(2));
+                Assert.Equal(10, c1.Value);
+                Assert.Equal(20, c2.Value);
+            });
+        }
+
+        [Fact]
+        private void EachSharedManaged()
+        {
+            using World world = World.Create();
+
+            world.Component<SharedComponent>().Entity.Add(Ecs.OnInstantiate, Ecs.Inherit);
+
+            using Query<ManagedComponent, SharedComponent> query = world.Query<ManagedComponent, SharedComponent>();
+
+            Entity prefab = world.Prefab()
+                .Set(new ManagedComponent(10))
+                .Set(new SharedComponent(20));
+
+            for (int i = 0; i < 5; i++)
+                world.Entity().IsA(prefab);
+
+            Assert.True(query.IsTrue());
+            Assert.Equal(5, query.Count());
+
+            query.Each(static (Iter it, int _, ref ManagedComponent c1, ref SharedComponent c2) =>
+            {
+                Assert.Equal(IterationTechnique.Shared, it.GetIterationTechnique(2));
+                Assert.Equal(10, c1.Value);
+                Assert.Equal(20, c2.Value);
+            });
+        }
+
+        [Fact]
+        private void EachSparseUnmanaged()
+        {
+            using World world = World.Create();
+
+            world.Component<SparseComponent>().Entity.Add(Ecs.Sparse);
+
+            using Query<UnmanagedComponent, SparseComponent> query = world.Query<UnmanagedComponent, SparseComponent>();
+
+            Entity prefab = world.Prefab()
+                .Set(new UnmanagedComponent(10))
+                .Set(new SparseComponent(20));
+
+            for (int i = 0; i < 5; i++)
+                world.Entity().IsA(prefab);
+
+            Assert.True(query.IsTrue());
+            Assert.Equal(5, query.Count());
+
+            query.Each(static (Iter it, int _, ref UnmanagedComponent c1, ref SparseComponent c2) =>
+            {
+                Assert.Equal(IterationTechnique.Sparse, it.GetIterationTechnique(2));
+                Assert.Equal(10, c1.Value);
+                Assert.Equal(20, c2.Value);
+            });
+        }
+
+        [Fact]
+        private void EachSparseManaged()
+        {
+            using World world = World.Create();
+
+            world.Component<SparseComponent>().Entity.Add(Ecs.Sparse);
+
+            using Query<ManagedComponent, SparseComponent> query = world.Query<ManagedComponent, SparseComponent>();
+
+            Entity prefab = world.Prefab()
+                .Set(new ManagedComponent(10))
+                .Set(new SparseComponent(20));
+
+            for (int i = 0; i < 5; i++)
+                world.Entity().IsA(prefab);
+
+            Assert.True(query.IsTrue());
+            Assert.Equal(5, query.Count());
+
+            query.Each(static (Iter it, int _, ref ManagedComponent c1, ref SparseComponent c2) =>
+            {
+                Assert.Equal(IterationTechnique.Sparse, it.GetIterationTechnique(2));
+                Assert.Equal(10, c1.Value);
+                Assert.Equal(20, c2.Value);
+            });
+        }
+
+        [Fact]
+        private void EachSparseSharedUnmanaged()
+        {
+            using World world = World.Create();
+
+            world.Component<SparseComponent>().Entity.Add(Ecs.Sparse);
+            world.Component<SharedComponent>().Entity.Add(Ecs.OnInstantiate, Ecs.Inherit);
+
+            using Query<UnmanagedComponent, SparseComponent, SharedComponent> query = world.Query<UnmanagedComponent, SparseComponent, SharedComponent>();
+
+            Entity prefab = world.Prefab()
+                .Set(new UnmanagedComponent(10))
+                .Set(new SparseComponent(20))
+                .Set(new SharedComponent(30));
+
+            for (int i = 0; i < 5; i++)
+                world.Entity().IsA(prefab);
+
+            Assert.True(query.IsTrue());
+            Assert.Equal(5, query.Count());
+
+            query.Each(static (Iter it, int _, ref UnmanagedComponent c1, ref SparseComponent c2, ref SharedComponent c3) =>
+            {
+                Assert.Equal(IterationTechnique.Sparse | IterationTechnique.Shared, it.GetIterationTechnique(3));
+                Assert.Equal(10, c1.Value);
+                Assert.Equal(20, c2.Value);
+                Assert.Equal(30, c3.Value);
+            });
+        }
+
+        [Fact]
+        private void EachSparseSharedManaged()
+        {
+            using World world = World.Create();
+
+            world.Component<SparseComponent>().Entity.Add(Ecs.Sparse);
+            world.Component<SharedComponent>().Entity.Add(Ecs.OnInstantiate, Ecs.Inherit);
+
+            using Query<ManagedComponent, SparseComponent, SharedComponent> query = world.Query<ManagedComponent, SparseComponent, SharedComponent>();
+
+            Entity prefab = world.Prefab()
+                .Set(new ManagedComponent(10))
+                .Set(new SparseComponent(20))
+                .Set(new SharedComponent(30));
+
+            for (int i = 0; i < 5; i++)
+                world.Entity().IsA(prefab);
+
+            Assert.True(query.IsTrue());
+            Assert.Equal(5, query.Count());
+
+            query.Each(static (Iter it, int _, ref ManagedComponent c1, ref SparseComponent c2, ref SharedComponent c3) =>
+            {
+                Assert.Equal(IterationTechnique.Sparse | IterationTechnique.Shared, it.GetIterationTechnique(3));
+                Assert.Equal(10, c1.Value);
+                Assert.Equal(20, c2.Value);
+                Assert.Equal(30, c3.Value);
+            });
+        }
     }
 }
diff --git a/src/Flecs.NET.Tests/CSharp/Core/TypeRegistrationTests.cs b/src/Flecs.NET.Tests/CSharp/Core/TypeRegistrationTests.cs
index 2fb9c493..13385080 100644
--- a/src/Flecs.NET.Tests/CSharp/Core/TypeRegistrationTests.cs
+++ b/src/Flecs.NET.Tests/CSharp/Core/TypeRegistrationTests.cs
@@ -85,7 +85,7 @@ private void TypeEnum(bool scoped)
             Assert.True(green.Has(EcsConstant, Ecs.Wildcard));
             Assert.True(blue.Has(EcsConstant, Ecs.Wildcard));
         }
-        
+
         [Fact]
         private void ComponentStructReflection()
         {
@@ -97,14 +97,14 @@ private void ComponentStructReflection()
             Assert.True(world.Entity(posComponent).Has<Type>());
             Assert.Equal(typeof(Position), world.Entity(posComponent).Get<Type>());
         }
-        
+
         [Fact]
         private void ComponentClassReflection()
         {
             using World world = World.Create();
 
             world.Component<ManagedComponent>();
-            Entity entity = world.Entity("Test").Set(new ManagedComponent());
+            Entity entity = world.Entity("Test").Set(new ManagedComponent(1));
             Id comp = entity.Table().Type().Get(0);
             Assert.True(world.Entity(comp).Has<Type>());
             Assert.Equal(typeof(ManagedComponent), world.Entity(comp).Get<Type>());
diff --git a/src/Flecs.NET.Tests/Cpp/ObserverTests.cs b/src/Flecs.NET.Tests/Cpp/ObserverTests.cs
index 304ee7d4..930d1ac4 100644
--- a/src/Flecs.NET.Tests/Cpp/ObserverTests.cs
+++ b/src/Flecs.NET.Tests/Cpp/ObserverTests.cs
@@ -870,6 +870,29 @@ private void OnSetWithDeferSet()
             Assert.Equal(1, count);
         }
 
+        [Fact]
+        private void OnSetWithSetSetSparse()
+        {
+            using World world = World.Create();
+
+            world.Component<Position>().Entity.Add(Ecs.Sparse);
+
+            int count = 0;
+
+            world.Observer<Position>()
+                .Event(Ecs.OnSet)
+                .Each((Entity _, ref Position _) =>
+                {
+                    count++;
+                });
+
+            Entity e = world.Entity();
+            Assert.Equal(0, count);
+
+            e.Set(new Position(10, 20));
+            Assert.Equal(1, count);
+        }
+
         [Fact]
         private void OnAddSingleton()
         {
diff --git a/src/Flecs.NET.Tests/Cpp/QueryTests.cs b/src/Flecs.NET.Tests/Cpp/QueryTests.cs
index 083e851b..458fcd72 100644
--- a/src/Flecs.NET.Tests/Cpp/QueryTests.cs
+++ b/src/Flecs.NET.Tests/Cpp/QueryTests.cs
@@ -566,7 +566,7 @@ private void FindWithEntity()
         }
 
         [Fact]
-        private void Action()
+        private void Run()
         {
             using World world = World.Create();
 
@@ -600,7 +600,7 @@ private void Action()
         }
 
         [Fact]
-        private void ActionConst()
+        private void RunConst()
         {
             using World world = World.Create();
 
@@ -634,7 +634,7 @@ private void ActionConst()
         }
 
         [Fact]
-        private void ActionShared()
+        private void RunShared()
         {
             using World world = World.Create();
 
@@ -688,7 +688,7 @@ private void ActionShared()
         }
 
         [Fact]
-        private void ActionOptional()
+        private void RunOptional()
         {
             using World world = World.Create();
 
@@ -757,6 +757,40 @@ private void ActionOptional()
             Assert.Equal(81, p->Y);
         }
 
+        [Fact]
+        private void RunSparse()
+        {
+            using World world = World.Create();
+
+            world.Component<Position>().Entity.Add(Ecs.Sparse);
+            world.Component<Velocity>();
+
+            Entity entity = world.Entity()
+                .Set(new Position(10, 20))
+                .Set(new Velocity(1, 2));
+
+            Query<Position, Velocity> q = world.Query<Position, Velocity>();
+
+            q.Run((Iter it) =>
+            {
+                while (it.Next())
+                {
+                    Field<Velocity> v = it.Field<Velocity>(1);
+
+                    foreach (int i in it)
+                    {
+                        ref Position p = ref it.FieldAt<Position>(0, i);
+                        p.X += v[i].X;
+                        p.Y += v[i].Y;
+                    }
+                }
+            });
+
+            Position* p = entity.GetPtr<Position>();
+            Assert.Equal(11, p->X);
+            Assert.Equal(22, p->Y);
+        }
+
         [Fact]
         private void Each()
         {
@@ -912,6 +946,31 @@ private void EachOptional()
             Assert.Equal(81, p->Y);
         }
 
+        [Fact]
+        private void EachSparse()
+        {
+            using World world = World.Create();
+
+            world.Component<Position>().Entity.Add(Ecs.Sparse);
+            world.Component<Velocity>();
+
+            Entity entity = world.Entity()
+                .Set(new Position(10, 20))
+                .Set(new Velocity(1, 2));
+
+            Query<Position, Velocity> q = world.Query<Position, Velocity>();
+
+            q.Each((ref Position p, ref Velocity v) =>
+            {
+                p.X += v.X;
+                p.Y += v.Y;
+            });
+
+            Position* p = entity.GetPtr<Position>();
+            Assert.Equal(11, p->X);
+            Assert.Equal(22, p->Y);
+        }
+
         [Fact]
         private void Signature()
         {
diff --git a/src/Flecs.NET.Tests/Helpers.cs b/src/Flecs.NET.Tests/Helpers.cs
index 2b5e81dd..71741cd3 100644
--- a/src/Flecs.NET.Tests/Helpers.cs
+++ b/src/Flecs.NET.Tests/Helpers.cs
@@ -29,6 +29,11 @@ public record struct Other(int Value);
 public record struct Singleton(int Value);
 public record struct PositionInitialized(float X, float Y);
 
+public record ManagedComponent(int Value);
+public record struct UnmanagedComponent(int Value);
+public record struct SharedComponent(int Value);
+public record struct SparseComponent(int Value);
+
 public record struct ManagedStruct(int Value)
 {
     public object Dummy = null!;
@@ -40,13 +45,6 @@ public class ManagedClass(int value)
     public object Dummy = null!;
 }
 
-public class ManagedComponent
-{
-    public string Value = null!;
-    public ManagedComponent Nested = null!;
-}
-
-
 public struct Base;
 public struct Prefab;
 
diff --git a/src/Flecs.NET/Core/BindingContext/Functions.cs b/src/Flecs.NET/Core/BindingContext/Functions.cs
index 10c5a5c0..37e63c7a 100644
--- a/src/Flecs.NET/Core/BindingContext/Functions.cs
+++ b/src/Flecs.NET/Core/BindingContext/Functions.cs
@@ -459,522 +459,325 @@ internal static void ManagedCopyCallbackPointer(GCHandle* dst, GCHandle* src, in
     internal static void OnAddIterFieldCallbackDelegate(ecs_iter_t* iter)
     {
         TypeHooksContext* context = (TypeHooksContext*)iter->callback_ctx;
-        Ecs.IterFieldCallback<T0> callback = (Ecs.IterFieldCallback<T0>)context->OnAdd.GcHandle.Target!;
-
-        for (int i = 0; i < iter->count; i++)
-            callback(iter, new Field<T0>(iter->ptrs[0], iter->count));
+        Invoker.Iter(iter, (Ecs.IterFieldCallback<T0>)context->OnAdd.GcHandle.Target!);
     }
 
     internal static void OnAddIterFieldCallbackPointer(ecs_iter_t* iter)
     {
         TypeHooksContext* context = (TypeHooksContext*)iter->callback_ctx;
-        delegate*<Iter, Field<T0>, void> callback = (delegate*<Iter, Field<T0>, void>)context->OnAdd.Pointer;
-
-        for (int i = 0; i < iter->count; i++)
-            callback(iter, new Field<T0>(iter->ptrs[0], iter->count));
+        Invoker.Iter(iter, (delegate*<Iter, Field<T0>, void>)context->OnAdd.Pointer);
     }
 
     internal static void OnAddIterSpanCallbackDelegate(ecs_iter_t* iter)
     {
         TypeHooksContext* context = (TypeHooksContext*)iter->callback_ctx;
-        Ecs.IterSpanCallback<T0> callback = (Ecs.IterSpanCallback<T0>)context->OnAdd.GcHandle.Target!;
-
-        for (int i = 0; i < iter->count; i++)
-            callback(iter, new Span<T0>(iter->ptrs[0], iter->count));
+        Invoker.Iter(iter, (Ecs.IterSpanCallback<T0>)context->OnAdd.GcHandle.Target!);
     }
 
     internal static void OnAddIterSpanCallbackPointer(ecs_iter_t* iter)
     {
         TypeHooksContext* context = (TypeHooksContext*)iter->callback_ctx;
-        delegate*<Iter, Span<T0>, void> callback = (delegate*<Iter, Span<T0>, void>)context->OnAdd.Pointer;
-
-        for (int i = 0; i < iter->count; i++)
-            callback(iter, new Span<T0>(iter->ptrs[0], iter->count));
+        Invoker.Iter(iter, (delegate*<Iter, Span<T0>, void>)context->OnAdd.Pointer);
     }
 
     internal static void OnAddIterPointerCallbackDelegate(ecs_iter_t* iter)
     {
         TypeHooksContext* context = (TypeHooksContext*)iter->callback_ctx;
-        Ecs.IterPointerCallback<T0> callback = (Ecs.IterPointerCallback<T0>)context->OnAdd.GcHandle.Target!;
-
-        for (int i = 0; i < iter->count; i++)
-            callback(iter, (T0*)iter->ptrs[0]);
+        Invoker.Iter(iter, (Ecs.IterPointerCallback<T0>)context->OnAdd.GcHandle.Target!);
     }
 
     internal static void OnAddIterPointerCallbackPointer(ecs_iter_t* iter)
     {
         TypeHooksContext* context = (TypeHooksContext*)iter->callback_ctx;
-        delegate*<Iter, T0*, void> callback = (delegate*<Iter, T0*, void>)context->OnAdd.Pointer;
-
-        for (int i = 0; i < iter->count; i++)
-            callback(iter, (T0*)iter->ptrs[0]);
+        Invoker.Iter(iter, (delegate*<Iter, T0*, void>)context->OnAdd.Pointer);
     }
 
     internal static void OnAddEachRefCallbackDelegate(ecs_iter_t* iter)
     {
         TypeHooksContext* context = (TypeHooksContext*)iter->callback_ctx;
-        Ecs.EachRefCallback<T0> callback = (Ecs.EachRefCallback<T0>)context->OnAdd.GcHandle.Target!;
+        Invoker.Each(iter, (Ecs.EachRefCallback<T0>)context->OnAdd.GcHandle.Target!);
 
-        T0* pointer = (T0*)iter->ptrs[0];
-        for (int i = 0; i < iter->count; i++)
-            callback(ref Managed.GetTypeRef<T0>(&pointer[i]));
     }
 
     internal static void OnAddEachRefCallbackPointer(ecs_iter_t* iter)
     {
         TypeHooksContext* context = (TypeHooksContext*)iter->callback_ctx;
-        delegate*<ref T0, void> callback = (delegate*<ref T0, void>)context->OnAdd.Pointer;
-
-        T0* pointer = (T0*)iter->ptrs[0];
-        for (int i = 0; i < iter->count; i++)
-            callback(ref Managed.GetTypeRef<T0>(&pointer[i]));
+        Invoker.Each(iter, (delegate*<ref T0, void>)context->OnAdd.Pointer);
     }
 
     internal static void OnAddEachEntityRefCallbackDelegate(ecs_iter_t* iter)
     {
         TypeHooksContext* context = (TypeHooksContext*)iter->callback_ctx;
-        Ecs.EachEntityRefCallback<T0> callback = (Ecs.EachEntityRefCallback<T0>)context->OnAdd.GcHandle.Target!;
-
-        T0* pointer = (T0*)iter->ptrs[0];
-        for (int i = 0; i < iter->count; i++)
-            callback(new Entity(iter->world, iter->entities[i]), ref Managed.GetTypeRef<T0>(&pointer[i]));
+        Invoker.Each(iter, (Ecs.EachEntityRefCallback<T0>)context->OnAdd.GcHandle.Target!);
     }
 
     internal static void OnAddEachEntityRefCallbackPointer(ecs_iter_t* iter)
     {
         TypeHooksContext* context = (TypeHooksContext*)iter->callback_ctx;
-        delegate*<Entity, ref T0, void> callback = (delegate*<Entity, ref T0, void>)context->OnAdd.Pointer;
-
-        T0* pointer = (T0*)iter->ptrs[0];
-        for (int i = 0; i < iter->count; i++)
-            callback(new Entity(iter->world, iter->entities[i]), ref Managed.GetTypeRef<T0>(&pointer[i]));
+        Invoker.Each(iter, (delegate*<Entity, ref T0, void>)context->OnAdd.Pointer);
     }
 
     internal static void OnAddEachIterRefCallbackDelegate(ecs_iter_t* iter)
     {
         TypeHooksContext* context = (TypeHooksContext*)iter->callback_ctx;
-        Ecs.EachIterRefCallback<T0> callback = (Ecs.EachIterRefCallback<T0>)context->OnAdd.GcHandle.Target!;
-
-        T0* pointer = (T0*)iter->ptrs[0];
-        for (int i = 0; i < iter->count; i++)
-            callback(new Iter(iter), i, ref Managed.GetTypeRef<T0>(&pointer[i]));
+        Invoker.Each(iter, (Ecs.EachIterRefCallback<T0>)context->OnAdd.GcHandle.Target!);
     }
 
     internal static void OnAddEachIterRefCallbackPointer(ecs_iter_t* iter)
     {
         TypeHooksContext* context = (TypeHooksContext*)iter->callback_ctx;
-        delegate*<Iter, int, ref T0, void> callback = (delegate*<Iter, int, ref T0, void>)context->OnAdd.Pointer;
-
-        T0* pointer = (T0*)iter->ptrs[0];
-        for (int i = 0; i < iter->count; i++)
-            callback(new Iter(iter), i, ref Managed.GetTypeRef<T0>(&pointer[i]));
+        Invoker.Each(iter, (delegate*<Iter, int, ref T0, void>)context->OnAdd.Pointer);
     }
 
     internal static void OnAddEachPointerCallbackDelegate(ecs_iter_t* iter)
     {
         TypeHooksContext* context = (TypeHooksContext*)iter->callback_ctx;
-        Ecs.EachPointerCallback<T0> callback = (Ecs.EachPointerCallback<T0>)context->OnAdd.GcHandle.Target!;
-
-        T0* pointer = (T0*)iter->ptrs[0];
-        for (int i = 0; i < iter->count; i++)
-            callback(&pointer[i]);
+        Invoker.Each(iter, (Ecs.EachPointerCallback<T0>)context->OnAdd.GcHandle.Target!);
     }
 
     internal static void OnAddEachPointerCallbackPointer(ecs_iter_t* iter)
     {
         TypeHooksContext* context = (TypeHooksContext*)iter->callback_ctx;
-        delegate*<T0*, void> callback = (delegate*<T0*, void>)context->OnAdd.Pointer;
-
-        T0* pointer = (T0*)iter->ptrs[0];
-        for (int i = 0; i < iter->count; i++)
-            callback(&pointer[i]);
+        Invoker.Each(iter, (delegate*<T0*, void>)context->OnAdd.Pointer);
     }
 
     internal static void OnAddEachEntityPointerCallbackDelegate(ecs_iter_t* iter)
     {
         TypeHooksContext* context = (TypeHooksContext*)iter->callback_ctx;
-        Ecs.EachEntityPointerCallback<T0> callback = (Ecs.EachEntityPointerCallback<T0>)context->OnAdd.GcHandle.Target!;
-
-        T0* pointer = (T0*)iter->ptrs[0];
-        for (int i = 0; i < iter->count; i++)
-            callback(new Entity(iter->world, iter->entities[i]), &pointer[i]);
+        Invoker.Each(iter, (Ecs.EachEntityPointerCallback<T0>)context->OnAdd.GcHandle.Target!);
     }
 
     internal static void OnAddEachEntityPointerCallbackPointer(ecs_iter_t* iter)
     {
         TypeHooksContext* context = (TypeHooksContext*)iter->callback_ctx;
-        delegate*<Entity, T0*, void> callback = (delegate*<Entity, T0*, void>)context->OnAdd.Pointer;
-
-        T0* pointer = (T0*)iter->ptrs[0];
-        for (int i = 0; i < iter->count; i++)
-            callback(new Entity(iter->world, iter->entities[i]), &pointer[i]);
+        Invoker.Each(iter, (delegate*<Entity, T0*, void>)context->OnAdd.Pointer);
     }
 
     internal static void OnAddEachIterPointerCallbackDelegate(ecs_iter_t* iter)
     {
         TypeHooksContext* context = (TypeHooksContext*)iter->callback_ctx;
-        Ecs.EachIterPointerCallback<T0> callback = (Ecs.EachIterPointerCallback<T0>)context->OnAdd.GcHandle.Target!;
-
-        T0* pointer = (T0*)iter->ptrs[0];
-        for (int i = 0; i < iter->count; i++)
-            callback(new Iter(iter), i, &pointer[i]);
+        Invoker.Each(iter, (Ecs.EachIterPointerCallback<T0>)context->OnAdd.GcHandle.Target!);
     }
 
     internal static void OnAddEachIterPointerCallbackPointer(ecs_iter_t* iter)
     {
         TypeHooksContext* context = (TypeHooksContext*)iter->callback_ctx;
-        delegate*<Iter, int, T0*, void> callback = (delegate*<Iter, int, T0*, void>)context->OnAdd.Pointer;
-
-        T0* pointer = (T0*)iter->ptrs[0];
-        for (int i = 0; i < iter->count; i++)
-            callback(new Iter(iter), i, &pointer[i]);
+        Invoker.Each(iter, (delegate*<Iter, int, T0*, void>)context->OnAdd.Pointer);
     }
 
     internal static void OnSetIterFieldCallbackDelegate(ecs_iter_t* iter)
     {
         TypeHooksContext* context = (TypeHooksContext*)iter->callback_ctx;
-        Ecs.IterFieldCallback<T0> callback = (Ecs.IterFieldCallback<T0>)context->OnSet.GcHandle.Target!;
-
-        for (int i = 0; i < iter->count; i++)
-            callback(iter, new Field<T0>(iter->ptrs[0], iter->count));
+        Invoker.Iter(iter, (Ecs.IterFieldCallback<T0>)context->OnSet.GcHandle.Target!);
     }
 
     internal static void OnSetIterFieldCallbackPointer(ecs_iter_t* iter)
     {
         TypeHooksContext* context = (TypeHooksContext*)iter->callback_ctx;
-        delegate*<Iter, Field<T0>, void> callback = (delegate*<Iter, Field<T0>, void>)context->OnSet.Pointer;
-
-        for (int i = 0; i < iter->count; i++)
-            callback(iter, new Field<T0>(iter->ptrs[0], iter->count));
+        Invoker.Iter(iter, (delegate*<Iter, Field<T0>, void>)context->OnSet.Pointer);
     }
 
     internal static void OnSetIterSpanCallbackDelegate(ecs_iter_t* iter)
     {
         TypeHooksContext* context = (TypeHooksContext*)iter->callback_ctx;
-        Ecs.IterSpanCallback<T0> callback = (Ecs.IterSpanCallback<T0>)context->OnSet.GcHandle.Target!;
-
-        for (int i = 0; i < iter->count; i++)
-            callback(iter, new Span<T0>(iter->ptrs[0], iter->count));
+        Invoker.Iter(iter, (Ecs.IterSpanCallback<T0>)context->OnSet.GcHandle.Target!);
     }
 
     internal static void OnSetIterSpanCallbackPointer(ecs_iter_t* iter)
     {
         TypeHooksContext* context = (TypeHooksContext*)iter->callback_ctx;
-        delegate*<Iter, Span<T0>, void> callback = (delegate*<Iter, Span<T0>, void>)context->OnSet.Pointer;
-
-        for (int i = 0; i < iter->count; i++)
-            callback(iter, new Span<T0>(iter->ptrs[0], iter->count));
+        Invoker.Iter(iter, (delegate*<Iter, Span<T0>, void>)context->OnSet.Pointer);
     }
 
     internal static void OnSetIterPointerCallbackDelegate(ecs_iter_t* iter)
     {
         TypeHooksContext* context = (TypeHooksContext*)iter->callback_ctx;
-        Ecs.IterPointerCallback<T0> callback = (Ecs.IterPointerCallback<T0>)context->OnSet.GcHandle.Target!;
-
-        for (int i = 0; i < iter->count; i++)
-            callback(iter, (T0*)iter->ptrs[0]);
+        Invoker.Iter(iter, (Ecs.IterPointerCallback<T0>)context->OnSet.GcHandle.Target!);
     }
 
     internal static void OnSetIterPointerCallbackPointer(ecs_iter_t* iter)
     {
         TypeHooksContext* context = (TypeHooksContext*)iter->callback_ctx;
-        delegate*<Iter, T0*, void> callback = (delegate*<Iter, T0*, void>)context->OnSet.Pointer;
-
-        for (int i = 0; i < iter->count; i++)
-            callback(iter, (T0*)iter->ptrs[0]);
+        Invoker.Iter(iter, (delegate*<Iter, T0*, void>)context->OnSet.Pointer);
     }
 
     internal static void OnSetEachRefCallbackDelegate(ecs_iter_t* iter)
     {
         TypeHooksContext* context = (TypeHooksContext*)iter->callback_ctx;
-        Ecs.EachRefCallback<T0> callback = (Ecs.EachRefCallback<T0>)context->OnSet.GcHandle.Target!;
-
-        T0* pointer = (T0*)iter->ptrs[0];
-        for (int i = 0; i < iter->count; i++)
-            callback(ref Managed.GetTypeRef<T0>(&pointer[i]));
+        Invoker.Each(iter, (Ecs.EachRefCallback<T0>)context->OnSet.GcHandle.Target!);
     }
 
     internal static void OnSetEachRefCallbackPointer(ecs_iter_t* iter)
     {
         TypeHooksContext* context = (TypeHooksContext*)iter->callback_ctx;
-        delegate*<ref T0, void> callback = (delegate*<ref T0, void>)context->OnSet.Pointer;
-
-        T0* pointer = (T0*)iter->ptrs[0];
-        for (int i = 0; i < iter->count; i++)
-            callback(ref Managed.GetTypeRef<T0>(&pointer[i]));
+        Invoker.Each(iter, (delegate*<ref T0, void>)context->OnSet.Pointer);
     }
 
     internal static void OnSetEachEntityRefCallbackDelegate(ecs_iter_t* iter)
     {
         TypeHooksContext* context = (TypeHooksContext*)iter->callback_ctx;
-        Ecs.EachEntityRefCallback<T0> callback = (Ecs.EachEntityRefCallback<T0>)context->OnSet.GcHandle.Target!;
-
-        T0* pointer = (T0*)iter->ptrs[0];
-        for (int i = 0; i < iter->count; i++)
-            callback(new Entity(iter->world, iter->entities[i]), ref Managed.GetTypeRef<T0>(&pointer[i]));
+        Invoker.Each(iter, (Ecs.EachEntityRefCallback<T0>)context->OnSet.GcHandle.Target!);
     }
 
     internal static void OnSetEachEntityRefCallbackPointer(ecs_iter_t* iter)
     {
         TypeHooksContext* context = (TypeHooksContext*)iter->callback_ctx;
-        delegate*<Entity, ref T0, void> callback = (delegate*<Entity, ref T0, void>)context->OnSet.Pointer;
-
-        T0* pointer = (T0*)iter->ptrs[0];
-        for (int i = 0; i < iter->count; i++)
-            callback(new Entity(iter->world, iter->entities[i]), ref Managed.GetTypeRef<T0>(&pointer[i]));
+        Invoker.Each(iter, (delegate*<Entity, ref T0, void>)context->OnSet.Pointer);
     }
 
     internal static void OnSetEachIterRefCallbackDelegate(ecs_iter_t* iter)
     {
         TypeHooksContext* context = (TypeHooksContext*)iter->callback_ctx;
-        Ecs.EachIterRefCallback<T0> callback = (Ecs.EachIterRefCallback<T0>)context->OnSet.GcHandle.Target!;
-
-        T0* pointer = (T0*)iter->ptrs[0];
-        for (int i = 0; i < iter->count; i++)
-            callback(new Iter(iter), i, ref Managed.GetTypeRef<T0>(&pointer[i]));
+        Invoker.Each(iter, (Ecs.EachIterRefCallback<T0>)context->OnSet.GcHandle.Target!);
     }
 
     internal static void OnSetEachIterRefCallbackPointer(ecs_iter_t* iter)
     {
         TypeHooksContext* context = (TypeHooksContext*)iter->callback_ctx;
-        delegate*<Iter, int, ref T0, void> callback = (delegate*<Iter, int, ref T0, void>)context->OnSet.Pointer;
-
-        T0* pointer = (T0*)iter->ptrs[0];
-        for (int i = 0; i < iter->count; i++)
-            callback(new Iter(iter), i, ref Managed.GetTypeRef<T0>(&pointer[i]));
+        Invoker.Each(iter, (delegate*<Iter, int, ref T0, void>)context->OnSet.Pointer);
     }
 
     internal static void OnSetEachPointerCallbackDelegate(ecs_iter_t* iter)
     {
         TypeHooksContext* context = (TypeHooksContext*)iter->callback_ctx;
-        Ecs.EachPointerCallback<T0> callback = (Ecs.EachPointerCallback<T0>)context->OnSet.GcHandle.Target!;
-
-        T0* pointer = (T0*)iter->ptrs[0];
-        for (int i = 0; i < iter->count; i++)
-            callback(&pointer[i]);
+        Invoker.Each(iter, (Ecs.EachPointerCallback<T0>)context->OnSet.GcHandle.Target!);
     }
 
     internal static void OnSetEachPointerCallbackPointer(ecs_iter_t* iter)
     {
         TypeHooksContext* context = (TypeHooksContext*)iter->callback_ctx;
-        delegate*<T0*, void> callback = (delegate*<T0*, void>)context->OnSet.Pointer;
-
-        T0* pointer = (T0*)iter->ptrs[0];
-        for (int i = 0; i < iter->count; i++)
-            callback(&pointer[i]);
+        Invoker.Each(iter, (delegate*<T0*, void>)context->OnSet.Pointer);
     }
 
     internal static void OnSetEachEntityPointerCallbackDelegate(ecs_iter_t* iter)
     {
         TypeHooksContext* context = (TypeHooksContext*)iter->callback_ctx;
-        Ecs.EachEntityPointerCallback<T0> callback = (Ecs.EachEntityPointerCallback<T0>)context->OnSet.GcHandle.Target!;
-
-        T0* pointer = (T0*)iter->ptrs[0];
-        for (int i = 0; i < iter->count; i++)
-            callback(new Entity(iter->world, iter->entities[i]), &pointer[i]);
+        Invoker.Each(iter, (Ecs.EachEntityPointerCallback<T0>)context->OnSet.GcHandle.Target!);
     }
 
     internal static void OnSetEachEntityPointerCallbackPointer(ecs_iter_t* iter)
     {
         TypeHooksContext* context = (TypeHooksContext*)iter->callback_ctx;
-        delegate*<Entity, T0*, void> callback = (delegate*<Entity, T0*, void>)context->OnSet.Pointer;
-
-        T0* pointer = (T0*)iter->ptrs[0];
-        for (int i = 0; i < iter->count; i++)
-            callback(new Entity(iter->world, iter->entities[i]), &pointer[i]);
+        Invoker.Each(iter, (delegate*<Entity, T0*, void>)context->OnSet.Pointer);
     }
 
     internal static void OnSetEachIterPointerCallbackDelegate(ecs_iter_t* iter)
     {
         TypeHooksContext* context = (TypeHooksContext*)iter->callback_ctx;
-        Ecs.EachIterPointerCallback<T0> callback = (Ecs.EachIterPointerCallback<T0>)context->OnSet.GcHandle.Target!;
-
-        T0* pointer = (T0*)iter->ptrs[0];
-        for (int i = 0; i < iter->count; i++)
-            callback(new Iter(iter), i, &pointer[i]);
+        Invoker.Each(iter, (Ecs.EachIterPointerCallback<T0>)context->OnSet.GcHandle.Target!);
     }
 
     internal static void OnSetEachIterPointerCallbackPointer(ecs_iter_t* iter)
     {
         TypeHooksContext* context = (TypeHooksContext*)iter->callback_ctx;
-        delegate*<Iter, int, T0*, void> callback = (delegate*<Iter, int, T0*, void>)context->OnSet.Pointer;
-
-        T0* pointer = (T0*)iter->ptrs[0];
-        for (int i = 0; i < iter->count; i++)
-            callback(new Iter(iter), i, &pointer[i]);
+        Invoker.Each(iter, (delegate*<Iter, int, T0*, void>)context->OnSet.Pointer);
     }
 
     internal static void OnRemoveIterFieldCallbackDelegate(ecs_iter_t* iter)
     {
         TypeHooksContext* context = (TypeHooksContext*)iter->callback_ctx;
-        Ecs.IterFieldCallback<T0> callback = (Ecs.IterFieldCallback<T0>)context->OnRemove.GcHandle.Target!;
-
-        for (int i = 0; i < iter->count; i++)
-            callback(iter, new Field<T0>(iter->ptrs[0], iter->count));
+        Invoker.Iter(iter, (Ecs.IterFieldCallback<T0>)context->OnRemove.GcHandle.Target!);
     }
 
     internal static void OnRemoveIterFieldCallbackPointer(ecs_iter_t* iter)
     {
         TypeHooksContext* context = (TypeHooksContext*)iter->callback_ctx;
-        delegate*<Iter, Field<T0>, void> callback = (delegate*<Iter, Field<T0>, void>)context->OnRemove.Pointer;
-
-        for (int i = 0; i < iter->count; i++)
-            callback(iter, new Field<T0>(iter->ptrs[0], iter->count));
+        Invoker.Iter(iter, (delegate*<Iter, Field<T0>, void>)context->OnRemove.Pointer);
     }
 
     internal static void OnRemoveIterSpanCallbackDelegate(ecs_iter_t* iter)
     {
         TypeHooksContext* context = (TypeHooksContext*)iter->callback_ctx;
-        Ecs.IterSpanCallback<T0> callback = (Ecs.IterSpanCallback<T0>)context->OnRemove.GcHandle.Target!;
-
-        for (int i = 0; i < iter->count; i++)
-            callback(iter, new Span<T0>(iter->ptrs[0], iter->count));
+        Invoker.Iter(iter, (Ecs.IterSpanCallback<T0>)context->OnRemove.GcHandle.Target!);
     }
 
     internal static void OnRemoveIterSpanCallbackPointer(ecs_iter_t* iter)
     {
         TypeHooksContext* context = (TypeHooksContext*)iter->callback_ctx;
-        delegate*<Iter, Span<T0>, void> callback = (delegate*<Iter, Span<T0>, void>)context->OnRemove.Pointer;
-
-        for (int i = 0; i < iter->count; i++)
-            callback(iter, new Span<T0>(iter->ptrs[0], iter->count));
+        Invoker.Iter(iter, (delegate*<Iter, Span<T0>, void>)context->OnRemove.Pointer);
     }
 
     internal static void OnRemoveIterPointerCallbackDelegate(ecs_iter_t* iter)
     {
         TypeHooksContext* context = (TypeHooksContext*)iter->callback_ctx;
-        Ecs.IterPointerCallback<T0> callback = (Ecs.IterPointerCallback<T0>)context->OnRemove.GcHandle.Target!;
-
-        for (int i = 0; i < iter->count; i++)
-            callback(iter, (T0*)iter->ptrs[0]);
+        Invoker.Iter(iter, (Ecs.IterPointerCallback<T0>)context->OnRemove.GcHandle.Target!);
     }
 
     internal static void OnRemoveIterPointerCallbackPointer(ecs_iter_t* iter)
     {
         TypeHooksContext* context = (TypeHooksContext*)iter->callback_ctx;
-        delegate*<Iter, T0*, void> callback = (delegate*<Iter, T0*, void>)context->OnRemove.Pointer;
-
-        for (int i = 0; i < iter->count; i++)
-            callback(iter, (T0*)iter->ptrs[0]);
+        Invoker.Iter(iter, (delegate*<Iter, T0*, void>)context->OnRemove.Pointer);
     }
 
     internal static void OnRemoveEachRefCallbackDelegate(ecs_iter_t* iter)
     {
         TypeHooksContext* context = (TypeHooksContext*)iter->callback_ctx;
-        Ecs.EachRefCallback<T0> callback = (Ecs.EachRefCallback<T0>)context->OnRemove.GcHandle.Target!;
-
-        T0* pointer = (T0*)iter->ptrs[0];
-        for (int i = 0; i < iter->count; i++)
-            callback(ref Managed.GetTypeRef<T0>(&pointer[i]));
+        Invoker.Each(iter, (Ecs.EachRefCallback<T0>)context->OnRemove.GcHandle.Target!);
     }
 
     internal static void OnRemoveEachRefCallbackPointer(ecs_iter_t* iter)
     {
         TypeHooksContext* context = (TypeHooksContext*)iter->callback_ctx;
-        delegate*<ref T0, void> callback = (delegate*<ref T0, void>)context->OnRemove.Pointer;
-
-        T0* pointer = (T0*)iter->ptrs[0];
-        for (int i = 0; i < iter->count; i++)
-            callback(ref Managed.GetTypeRef<T0>(&pointer[i]));
+        Invoker.Each(iter, (delegate*<ref T0, void>)context->OnRemove.Pointer);
     }
 
     internal static void OnRemoveEachEntityRefCallbackDelegate(ecs_iter_t* iter)
     {
         TypeHooksContext* context = (TypeHooksContext*)iter->callback_ctx;
-        Ecs.EachEntityRefCallback<T0> callback = (Ecs.EachEntityRefCallback<T0>)context->OnRemove.GcHandle.Target!;
-
-        T0* pointer = (T0*)iter->ptrs[0];
-        for (int i = 0; i < iter->count; i++)
-            callback(new Entity(iter->world, iter->entities[i]), ref Managed.GetTypeRef<T0>(&pointer[i]));
+        Invoker.Each(iter, (Ecs.EachEntityRefCallback<T0>)context->OnRemove.GcHandle.Target!);
     }
 
     internal static void OnRemoveEachEntityRefCallbackPointer(ecs_iter_t* iter)
     {
         TypeHooksContext* context = (TypeHooksContext*)iter->callback_ctx;
-        delegate*<Entity, ref T0, void> callback = (delegate*<Entity, ref T0, void>)context->OnRemove.Pointer;
-
-        T0* pointer = (T0*)iter->ptrs[0];
-        for (int i = 0; i < iter->count; i++)
-            callback(new Entity(iter->world, iter->entities[i]), ref Managed.GetTypeRef<T0>(&pointer[i]));
+        Invoker.Each(iter, (delegate*<Entity, ref T0, void>)context->OnRemove.Pointer);
     }
 
     internal static void OnRemoveEachIterRefCallbackDelegate(ecs_iter_t* iter)
     {
         TypeHooksContext* context = (TypeHooksContext*)iter->callback_ctx;
-        Ecs.EachIterRefCallback<T0> callback = (Ecs.EachIterRefCallback<T0>)context->OnRemove.GcHandle.Target!;
-
-        T0* pointer = (T0*)iter->ptrs[0];
-        for (int i = 0; i < iter->count; i++)
-            callback(new Iter(iter), i, ref Managed.GetTypeRef<T0>(&pointer[i]));
+        Invoker.Each(iter, (Ecs.EachIterRefCallback<T0>)context->OnRemove.GcHandle.Target!);
     }
 
     internal static void OnRemoveEachIterRefCallbackPointer(ecs_iter_t* iter)
     {
         TypeHooksContext* context = (TypeHooksContext*)iter->callback_ctx;
-        delegate*<Iter, int, ref T0, void> callback = (delegate*<Iter, int, ref T0, void>)context->OnRemove.Pointer;
-
-        T0* pointer = (T0*)iter->ptrs[0];
-        for (int i = 0; i < iter->count; i++)
-            callback(new Iter(iter), i, ref Managed.GetTypeRef<T0>(&pointer[i]));
+        Invoker.Each(iter, (delegate*<Iter, int, ref T0, void>)context->OnRemove.Pointer);
     }
 
     internal static void OnRemoveEachPointerCallbackDelegate(ecs_iter_t* iter)
     {
         TypeHooksContext* context = (TypeHooksContext*)iter->callback_ctx;
-        Ecs.EachPointerCallback<T0> callback = (Ecs.EachPointerCallback<T0>)context->OnRemove.GcHandle.Target!;
-
-        T0* pointer = (T0*)iter->ptrs[0];
-        for (int i = 0; i < iter->count; i++)
-            callback(&pointer[i]);
+        Invoker.Each(iter, (Ecs.EachPointerCallback<T0>)context->OnRemove.GcHandle.Target!);
     }
 
     internal static void OnRemoveEachPointerCallbackPointer(ecs_iter_t* iter)
     {
         TypeHooksContext* context = (TypeHooksContext*)iter->callback_ctx;
-        delegate*<T0*, void> callback = (delegate*<T0*, void>)context->OnRemove.Pointer;
-
-        T0* pointer = (T0*)iter->ptrs[0];
-        for (int i = 0; i < iter->count; i++)
-            callback(&pointer[i]);
+        Invoker.Each(iter, (delegate*<T0*, void>)context->OnRemove.Pointer);
     }
 
     internal static void OnRemoveEachEntityPointerCallbackDelegate(ecs_iter_t* iter)
     {
         TypeHooksContext* context = (TypeHooksContext*)iter->callback_ctx;
-        Ecs.EachEntityPointerCallback<T0> callback = (Ecs.EachEntityPointerCallback<T0>)context->OnRemove.GcHandle.Target!;
-
-        T0* pointer = (T0*)iter->ptrs[0];
-        for (int i = 0; i < iter->count; i++)
-            callback(new Entity(iter->world, iter->entities[i]), &pointer[i]);
+        Invoker.Each(iter, (Ecs.EachEntityPointerCallback<T0>)context->OnRemove.GcHandle.Target!);
     }
 
     internal static void OnRemoveEachEntityPointerCallbackPointer(ecs_iter_t* iter)
     {
         TypeHooksContext* context = (TypeHooksContext*)iter->callback_ctx;
-        delegate*<Entity, T0*, void> callback = (delegate*<Entity, T0*, void>)context->OnRemove.Pointer;
-
-        T0* pointer = (T0*)iter->ptrs[0];
-        for (int i = 0; i < iter->count; i++)
-            callback(new Entity(iter->world, iter->entities[i]), &pointer[i]);
+        Invoker.Each(iter, (delegate*<Entity, T0*, void>)context->OnRemove.Pointer);
     }
 
     internal static void OnRemoveEachIterPointerCallbackDelegate(ecs_iter_t* iter)
     {
         TypeHooksContext* context = (TypeHooksContext*)iter->callback_ctx;
-        Ecs.EachIterPointerCallback<T0> callback = (Ecs.EachIterPointerCallback<T0>)context->OnRemove.GcHandle.Target!;
-
-        T0* pointer = (T0*)iter->ptrs[0];
-        for (int i = 0; i < iter->count; i++)
-            callback(new Iter(iter), i, &pointer[i]);
+        Invoker.Each(iter, (Ecs.EachIterPointerCallback<T0>)context->OnRemove.GcHandle.Target!);
     }
 
     internal static void OnRemoveEachIterPointerCallbackPointer(ecs_iter_t* iter)
     {
         TypeHooksContext* context = (TypeHooksContext*)iter->callback_ctx;
-        delegate*<Iter, int, T0*, void> callback = (delegate*<Iter, int, T0*, void>)context->OnRemove.Pointer;
-
-        T0* pointer = (T0*)iter->ptrs[0];
-        for (int i = 0; i < iter->count; i++)
-            callback(new Iter(iter), i, &pointer[i]);
+        Invoker.Each(iter, (delegate*<Iter, int, T0*, void>)context->OnRemove.Pointer);
     }
 }
diff --git a/src/Flecs.NET/Core/Ecs/Aliases.cs b/src/Flecs.NET/Core/Ecs/Aliases.cs
index 8af26c44..ceebe6a4 100644
--- a/src/Flecs.NET/Core/Ecs/Aliases.cs
+++ b/src/Flecs.NET/Core/Ecs/Aliases.cs
@@ -644,11 +644,6 @@ public static partial class Ecs
     /// </summary>
     public const uint QueryMatchEmptyTables = EcsQueryMatchEmptyTables;
 
-    /// <summary>
-    ///     Query won't provide component data.
-    /// </summary>
-    public const uint QueryNoData = EcsQueryNoData;
-
     /// <summary>
     ///     Query may have unresolved entity identifiers.
     /// </summary>
diff --git a/src/Flecs.NET/Core/Ecs/Macros.cs b/src/Flecs.NET/Core/Ecs/Macros.cs
index eedd59e4..767852e9 100644
--- a/src/Flecs.NET/Core/Ecs/Macros.cs
+++ b/src/Flecs.NET/Core/Ecs/Macros.cs
@@ -315,4 +315,10 @@ internal static ref QueryBuilder GetQueryBuilder<T>(ref T queryBuilder) where T
     {
         return ref queryBuilder.QueryBuilder;
     }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    internal static ref ecs_world_t* GetIterableWorld<T>(ref T obj) where T : IIterableBase
+    {
+        return ref obj.World;
+    }
 }
diff --git a/src/Flecs.NET/Core/Field.cs b/src/Flecs.NET/Core/Field.cs
index c83d5eae..c568064b 100644
--- a/src/Flecs.NET/Core/Field.cs
+++ b/src/Flecs.NET/Core/Field.cs
@@ -21,11 +21,6 @@ namespace Flecs.NET.Core;
     /// </summary>
     public int Length { get; }
 
-    /// <summary>
-    ///     Specifies if the field is shared.
-    /// </summary>
-    public bool IsShared { get; }
-
     /// <summary>
     ///     Specifies if the field pointer is null.
     /// </summary>
@@ -36,12 +31,10 @@ namespace Flecs.NET.Core;
     /// </summary>
     /// <param name="data"></param>
     /// <param name="length"></param>
-    /// <param name="isShared"></param>
-    public Field(void* data, int length, bool isShared = false)
+    public Field(void* data, int length)
     {
         Data = data;
         Length = length;
-        IsShared = isShared;
     }
 
     /// <summary>
@@ -53,8 +46,7 @@ public ref T this[int index]
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         get
         {
-            Ecs.Assert(index < Length, nameof(ECS_COLUMN_INDEX_OUT_OF_RANGE));
-            Ecs.Assert(index == 0 || !IsShared, nameof(ECS_INVALID_PARAMETER));
+            Ecs.Assert(index >= 0 && index < Length, nameof(ECS_COLUMN_INDEX_OUT_OF_RANGE));
             Ecs.Assert(Data != null, nameof(ECS_COLUMN_INDEX_OUT_OF_RANGE));
             return ref Managed.GetTypeRef<T>(Data, index);
         }
@@ -110,4 +102,4 @@ public override int GetHashCode()
     {
         return !(left == right);
     }
-}
\ No newline at end of file
+}
diff --git a/src/Flecs.NET/Core/FieldData.cs b/src/Flecs.NET/Core/FieldData.cs
new file mode 100644
index 00000000..2d7c3112
--- /dev/null
+++ b/src/Flecs.NET/Core/FieldData.cs
@@ -0,0 +1,130 @@
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using Flecs.NET.Utilities;
+using static Flecs.NET.Bindings.flecs;
+
+namespace Flecs.NET.Core;
+
+internal unsafe struct FieldData<T>()
+{
+    public T* Pointer;
+    public ecs_iter_t* Iter;
+    public byte Index;    // Field index.
+    public bool IsShared; // Is 0 indexed component.
+    public bool IsSparse; // Is sparse component.
+
+    public FieldData(ecs_iter_t* iter, byte index) : this()
+    {
+        Iter = iter;
+        Index = index;
+
+        if (Utils.IsBitSet(iter->row_fields, index))
+        {
+            IsSparse = true;
+        }
+        else
+        {
+            Pointer = (T*)ecs_field_w_size(iter, Type<T>.Size, index);
+            IsShared = iter->sources[index] != 0 || !Utils.IsBitSet(iter->set_fields, index);
+        }
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public readonly T* PointerUnmanaged(int row)
+    {
+        return &Pointer[row];
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public readonly T* PointerSharedUnmanaged(int row)
+    {
+        return IsShared ? PointerUnmanaged(0) : PointerUnmanaged(row);
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public readonly T* PointerSparseUnmanaged(int row)
+    {
+        return IsSparse ? (T*)ecs_field_at_w_size(Iter, Type<T>.Size, Index, row) : PointerUnmanaged(row);
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public readonly T* PointerSparseSharedUnmanaged(int row)
+    {
+        return IsSparse ? (T*)ecs_field_at_w_size(Iter, Type<T>.Size, Index, row) : PointerSharedUnmanaged(row);
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public readonly T* PointerManaged(int row)
+    {
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T>())
+            return (T*)&((GCHandle*)Pointer)[row];
+
+        return &Pointer[row];
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public readonly T* PointerSharedManaged(int row)
+    {
+        return IsShared ? PointerManaged(0) : PointerManaged(row);
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public readonly T* PointerSparseManaged(int row)
+    {
+        return IsSparse ? (T*)ecs_field_at_w_size(Iter, Type<T>.Size, Index, row) : PointerManaged(row);
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public readonly T* PointerSparseSharedManaged(int row)
+    {
+        return IsSparse ? (T*)ecs_field_at_w_size(Iter, Type<T>.Size, Index, row) : PointerSharedManaged(row);
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public readonly ref T RefUnmanaged(int row)
+    {
+        return ref *PointerUnmanaged(row);
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public readonly ref T RefSharedUnmanaged(int row)
+    {
+        return ref *PointerSharedUnmanaged(row);
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public readonly ref T RefSparseUnmanaged(int row)
+    {
+        return ref *PointerSparseUnmanaged(row);
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public readonly ref T RefSparseSharedUnmanaged(int row)
+    {
+        return ref *PointerSparseSharedUnmanaged(row);
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public readonly ref T RefManaged(int row)
+    {
+        return ref Managed.GetTypeRef<T>(PointerManaged(row));
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public readonly ref T RefSharedManaged(int row)
+    {
+        return ref Managed.GetTypeRef<T>(PointerSharedManaged(row));
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public readonly ref T RefSparseManaged(int row)
+    {
+        return ref Managed.GetTypeRef<T>(PointerSparseManaged(row));
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public readonly ref T RefSparseSharedManaged(int row)
+    {
+        return ref Managed.GetTypeRef<T>(PointerSparseSharedManaged(row));
+    }
+}
diff --git a/src/Flecs.NET/Core/IIterableBase.cs b/src/Flecs.NET/Core/IIterableBase.cs
index 88b71ea1..51fd7892 100644
--- a/src/Flecs.NET/Core/IIterableBase.cs
+++ b/src/Flecs.NET/Core/IIterableBase.cs
@@ -7,6 +7,11 @@ namespace Flecs.NET.Core;
 /// </summary>
 public unsafe interface IIterableBase
 {
+    /// <summary>
+    ///     Reference to the world.
+    /// </summary>
+    public ref ecs_world_t* World { get; }
+
     /// <summary>
     ///     Iterate a query.
     /// </summary>
diff --git a/src/Flecs.NET/Core/Invoker.cs b/src/Flecs.NET/Core/Invoker.cs
index cc05aea1..1f42e02b 100644
--- a/src/Flecs.NET/Core/Invoker.cs
+++ b/src/Flecs.NET/Core/Invoker.cs
@@ -40,8 +40,6 @@ public static void Each(ecs_iter_t* iter, Ecs.EachEntityCallback callback)
     {
         Ecs.Assert(iter->count > 0, "No entities returned, use Iter() or Each() without the entity argument instead.");
 
-        iter->flags |= EcsIterCppEach;
-
         Ecs.TableLock(iter->world, iter->table);
 
         for (int i = 0; i < iter->count; i++)
@@ -57,8 +55,6 @@ public static void Each(ecs_iter_t* iter, Ecs.EachEntityCallback callback)
     /// <param name="callback"></param>
     public static void Each(ecs_iter_t* iter, Ecs.EachIterCallback callback)
     {
-        iter->flags |= EcsIterCppEach;
-
         Ecs.TableLock(iter->world, iter->table);
 
         int count = iter->count == 0 && iter->table == null ? 1 : iter->count;
@@ -228,8 +224,6 @@ public static void Each(ecs_iter_t* iter, delegate*<Entity, void> callback)
     {
         Ecs.Assert(iter->count > 0, "No entities returned, use Iter() or Each() without the entity argument instead.");
 
-        iter->flags |= EcsIterCppEach;
-
         Ecs.TableLock(iter->world, iter->table);
 
         for (int i = 0; i < iter->count; i++)
@@ -245,8 +239,6 @@ public static void Each(ecs_iter_t* iter, delegate*<Entity, void> callback)
     /// <param name="callback"></param>
     public static void Each(ecs_iter_t* iter, delegate*<Iter, int, void> callback)
     {
-        iter->flags |= EcsIterCppEach;
-
         Ecs.TableLock(iter->world, iter->table);
 
         int count = iter->count == 0 && iter->table == null ? 1 : iter->count;
@@ -406,4 +398,4 @@ public static void Run<T>(ref T iterable, delegate*<Iter, void> callback) where
         ecs_iter_t iter = iterable.GetIter();
         Run(&iter, callback);
     }
-}
\ No newline at end of file
+}
diff --git a/src/Flecs.NET/Core/Iter.cs b/src/Flecs.NET/Core/Iter.cs
index 06f293bf..3e0a4ab8 100644
--- a/src/Flecs.NET/Core/Iter.cs
+++ b/src/Flecs.NET/Core/Iter.cs
@@ -208,7 +208,7 @@ public Entity Entity(int row)
     public bool IsSelf(int index)
     {
         Ecs.Assert(index < Handle->field_count, "Field index out of range.");
-        return ecs_field_is_self(Handle, index) == 1;
+        return ecs_field_is_self(Handle, (byte)index) == 1;
     }
 
     /// <summary>
@@ -219,7 +219,7 @@ public bool IsSelf(int index)
     public bool IsSet(int index)
     {
         Ecs.Assert(index < Handle->field_count, "Field index out of range.");
-        return ecs_field_is_set(Handle, index) == 1;
+        return ecs_field_is_set(Handle, (byte)index) == 1;
     }
 
     /// <summary>
@@ -230,7 +230,7 @@ public bool IsSet(int index)
     public bool IsReadonly(int index)
     {
         Ecs.Assert(index < Handle->field_count, "Field index out of range.");
-        return ecs_field_is_readonly(Handle, index) == 1;
+        return ecs_field_is_readonly(Handle, (byte)index) == 1;
     }
 
     /// <summary>
@@ -250,7 +250,7 @@ public int FieldCount()
     public ulong Size(int index)
     {
         Ecs.Assert(index < Handle->field_count, "Field index out of range.");
-        return (ulong)ecs_field_size(Handle, index);
+        return (ulong)ecs_field_size(Handle, (byte)index);
     }
 
     /// <summary>
@@ -261,7 +261,7 @@ public ulong Size(int index)
     public Entity Src(int index)
     {
         Ecs.Assert(index < Handle->field_count, "Field index out of range.");
-        return new Entity(Handle->world, ecs_field_src(Handle, index));
+        return new Entity(Handle->world, ecs_field_src(Handle, (byte)index));
     }
 
     /// <summary>
@@ -272,7 +272,7 @@ public Entity Src(int index)
     public Id Id(int index)
     {
         Ecs.Assert(index < Handle->field_count, "Field index out of range.");
-        return new Id(Handle->world, ecs_field_id(Handle, index));
+        return new Id(Handle->world, ecs_field_id(Handle, (byte)index));
     }
 
     /// <summary>
@@ -284,7 +284,7 @@ public Id Id(int index)
     public Id Pair(int index)
     {
         Ecs.Assert(index < Handle->field_count, "Field index out of range.");
-        ulong id = ecs_field_id(Handle, index);
+        ulong id = ecs_field_id(Handle, (byte)index);
         Ecs.Assert(Ecs.EntityHasIdFlag(id, ECS_PAIR) != 0, nameof(ECS_INVALID_PARAMETER));
         return new Id(Handle->world, id);
     }
@@ -297,7 +297,7 @@ public Id Pair(int index)
     public int ColumnIndex(int index)
     {
         Ecs.Assert(index < Handle->field_count, "Field index out of range.");
-        return ecs_field_column(Handle, index);
+        return ecs_field_column(Handle, (byte)index);
     }
 
     /// <summary>
@@ -331,7 +331,9 @@ public Field<T> Field<T>(int index)
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public ref T FieldAt<T>(int index, int row)
     {
-        return ref GetField<T>(index)[row];
+        return ref Utils.IsBitSet(Handle->row_fields, index)
+            ? ref GetFieldAt<T>(index, row)[0]
+            : ref GetField<T>(index)[row];
     }
 
     /// <summary>
@@ -456,8 +458,18 @@ public void Fini()
     internal Field<T> GetField<T>(int index)
     {
         AssertField<T>(Handle, index);
-        bool isShared = ecs_field_is_self(Handle, index) == 0;
-        return new Field<T>(Handle->ptrs[index], isShared ? 1 : Handle->count, isShared);
+
+        return new Field<T>(
+            ecs_field_w_size(Handle, Type<T>.Size, (byte)index),
+            ecs_field_is_self(Handle, (byte)index) == Utils.True ? Handle->count : 1
+        );
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    internal Field<T> GetFieldAt<T>(int index, int row)
+    {
+        AssertField<T>(Handle, index);
+        return new Field<T>(ecs_field_at_w_size(Handle, Type<T>.Size, (byte)index, row), 1);
     }
 
     [Conditional("DEBUG")]
@@ -676,19 +688,30 @@ internal Span<T> GetSpan<T>(int index)
     internal T* GetPointer<T>(int index)
     {
         AssertField<T>(Handle, index);
-        return (T*)Handle->ptrs[index];
+        return (T*)ecs_field_w_size(Handle, Type<T>.Size, (byte)index);
     }
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    internal int Step<T>(int index)
+    internal FieldData<T> GetFieldData<T>(byte index)
     {
-        return (Handle->sources == null || Handle->sources[index] == 0) && (Handle->set_fields & (1 << index)) != 0 && !Type<T>.IsTag ? Type<T>.Size : 0;
+        AssertField<T>(Handle, index);
+        return new FieldData<T>(Handle, index);
     }
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    internal bool IsLinear()
+    internal IterationTechnique GetIterationTechnique(int fieldCount)
     {
-        return Handle->shared_fields == 0 && Handle->set_fields == (1 << Handle->field_count) - 1;
+        IterationTechnique flags = default;
+
+        int mask = (1 << fieldCount) - 1;
+
+        if ((Handle->row_fields & mask) != 0)
+            flags |= IterationTechnique.Sparse;
+
+        if (((Handle->ref_fields & mask) != 0 && Handle->ref_fields != Handle->row_fields) || (Handle->up_fields & mask) != 0 || (Handle->set_fields & mask) != mask)
+            flags |= IterationTechnique.Shared;
+
+        return flags;
     }
 }
 
diff --git a/src/Flecs.NET/Core/IterIterable.cs b/src/Flecs.NET/Core/IterIterable.cs
index dfad9f9c..c230b972 100644
--- a/src/Flecs.NET/Core/IterIterable.cs
+++ b/src/Flecs.NET/Core/IterIterable.cs
@@ -299,6 +299,9 @@ public override int GetHashCode()
 // IIterableBase Interface
 public unsafe partial struct IterIterable
 {
+    /// <inheritdoc cref="IIterableBase.World"/>
+    public ref ecs_world_t* World => ref _iter.world;
+
     /// <inheritdoc cref="IIterableBase.GetIter"/>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public ecs_iter_t GetIter(ecs_world_t* world = null)
diff --git a/src/Flecs.NET/Core/IterationTechnique.cs b/src/Flecs.NET/Core/IterationTechnique.cs
new file mode 100644
index 00000000..de6ab49c
--- /dev/null
+++ b/src/Flecs.NET/Core/IterationTechnique.cs
@@ -0,0 +1,22 @@
+using System;
+
+namespace Flecs.NET.Core;
+
+[Flags]
+internal enum IterationTechnique
+{
+    /// <summary>
+    ///     Indicates default enum value.
+    /// </summary>
+    None = 0,
+
+    /// <summary>
+    ///     Indicates that query contains shared components.
+    /// </summary>
+    Shared = 1,
+
+    /// <summary>
+    ///     Indicates that query contains sparse components.
+    /// </summary>
+    Sparse = 2
+}
diff --git a/src/Flecs.NET/Core/PageIterable.cs b/src/Flecs.NET/Core/PageIterable.cs
index 8f031acd..b071bb75 100644
--- a/src/Flecs.NET/Core/PageIterable.cs
+++ b/src/Flecs.NET/Core/PageIterable.cs
@@ -82,6 +82,9 @@ public override int GetHashCode()
 // IIterableBase Interface
 public unsafe partial struct PageIterable
 {
+    /// <inheritdoc cref="IIterableBase.World"/>
+    public ref ecs_world_t* World => ref _iter.world;
+
     /// <inheritdoc cref="IIterableBase.GetIter"/>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public ecs_iter_t GetIter(ecs_world_t* world = null)
diff --git a/src/Flecs.NET/Core/Query.cs b/src/Flecs.NET/Core/Query.cs
index e8f9b5ca..5cfe1d1b 100644
--- a/src/Flecs.NET/Core/Query.cs
+++ b/src/Flecs.NET/Core/Query.cs
@@ -312,6 +312,9 @@ public World RealWorld()
 // IIterableBase Interface
 public unsafe partial struct Query
 {
+    /// <inheritdoc cref="IIterableBase.World"/>
+    ref ecs_world_t* IIterableBase.World => ref _handle->world;
+
     /// <inheritdoc cref="IIterableBase.GetIter"/>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public ecs_iter_t GetIter(ecs_world_t* world = null)
diff --git a/src/Flecs.NET/Core/WorkerIterable.cs b/src/Flecs.NET/Core/WorkerIterable.cs
index 53d5c817..28eefa7b 100644
--- a/src/Flecs.NET/Core/WorkerIterable.cs
+++ b/src/Flecs.NET/Core/WorkerIterable.cs
@@ -82,6 +82,9 @@ public override int GetHashCode()
 //IIterableBase Interface
 public unsafe partial struct WorkerIterable
 {
+    /// <inheritdoc cref="IIterableBase.World"/>
+    public ref ecs_world_t* World => ref _iter.world;
+
     /// <inheritdoc cref="IIterableBase.GetIter"/>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public ecs_iter_t GetIter(ecs_world_t* world = null)
diff --git a/src/Flecs.NET/Flecs.NET.csproj b/src/Flecs.NET/Flecs.NET.csproj
index baa6877b..01c974a9 100644
--- a/src/Flecs.NET/Flecs.NET.csproj
+++ b/src/Flecs.NET/Flecs.NET.csproj
@@ -20,7 +20,7 @@
         <IsPackable>true</IsPackable>
         <IncludeContentInPack>true</IncludeContentInPack>
 
-        <Version>4.0.0</Version>
+        <Version>4.0.1</Version>
         <Title Condition="'$(Configuration)' == 'Debug'">Flecs.NET.Debug</Title>
         <Title Condition="'$(Configuration)' == 'Release'">Flecs.NET.Release</Title>
         <Authors>BeanCheeseBurrito</Authors>
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/Invoker/Each/Iterator/T1.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/Invoker/Each/Iterator/T1.g.cs
index cd3c5e5e..cae85205 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/Invoker/Each/Iterator/T1.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/Invoker/Each/Iterator/T1.g.cs
@@ -1,5 +1,7 @@
 // Each/Iterator/T1.g.cs
 // File was auto-generated by /_/src/Flecs.NET.Codegen/Generators/Invoker.cs
+using System;
+using System.Runtime.CompilerServices;
 using Flecs.NET.Utilities;
 using static Flecs.NET.Bindings.flecs;
 
@@ -17,15 +19,93 @@ public static void Each<T0>(Iter it, Ecs.EachRefCallback<T0> callback)
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0);
-        int step0 = it.Step<T0>(0);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0);
+        IterationTechnique flags = it.GetIterationTechnique(1);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0])
-            callback(ref Managed.GetTypeRef<T0>(pointer0));
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, Ecs.EachRefCallback<T0> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, Ecs.EachRefCallback<T0> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, Ecs.EachRefCallback<T0> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, Ecs.EachRefCallback<T0> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, Ecs.EachRefCallback<T0> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, Ecs.EachRefCallback<T0> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, Ecs.EachRefCallback<T0> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, Ecs.EachRefCallback<T0> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSparseSharedManaged(i));
+        }
     }
 
     /// <summary>
@@ -38,15 +118,93 @@ public static void Each<T0>(Iter it, Ecs.EachEntityRefCallback<T0> callback)
     {
         int count = it.Handle->count; Ecs.Assert(it.Handle->count > 0, "No entities returned, use Iter() or Each() without the entity argument instead.");
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0);
-        int step0 = it.Step<T0>(0);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0);
+        IterationTechnique flags = it.GetIterationTechnique(1);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0])
-            callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref Managed.GetTypeRef<T0>(pointer0));
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, Ecs.EachEntityRefCallback<T0> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, Ecs.EachEntityRefCallback<T0> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, Ecs.EachEntityRefCallback<T0> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, Ecs.EachEntityRefCallback<T0> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, Ecs.EachEntityRefCallback<T0> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, Ecs.EachEntityRefCallback<T0> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, Ecs.EachEntityRefCallback<T0> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, Ecs.EachEntityRefCallback<T0> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseSharedManaged(i));
+        }
     }
 
     /// <summary>
@@ -59,15 +217,93 @@ public static void Each<T0>(Iter it, Ecs.EachIterRefCallback<T0> callback)
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0);
-        int step0 = it.Step<T0>(0);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0);
+        IterationTechnique flags = it.GetIterationTechnique(1);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0])
-            callback(it, i, ref Managed.GetTypeRef<T0>(pointer0));
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, Ecs.EachIterRefCallback<T0> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, Ecs.EachIterRefCallback<T0> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, Ecs.EachIterRefCallback<T0> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, Ecs.EachIterRefCallback<T0> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, Ecs.EachIterRefCallback<T0> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, Ecs.EachIterRefCallback<T0> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, Ecs.EachIterRefCallback<T0> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, Ecs.EachIterRefCallback<T0> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSparseSharedManaged(i));
+        }
     }
 
     /// <summary>
@@ -80,15 +316,93 @@ public static void Each<T0>(Iter it, delegate*<ref T0, void> callback)
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0);
-        int step0 = it.Step<T0>(0);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0);
+        IterationTechnique flags = it.GetIterationTechnique(1);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0])
-            callback(ref Managed.GetTypeRef<T0>(pointer0));
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, delegate*<ref T0, void> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, delegate*<ref T0, void> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, delegate*<ref T0, void> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, delegate*<ref T0, void> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, delegate*<ref T0, void> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, delegate*<ref T0, void> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, delegate*<ref T0, void> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, delegate*<ref T0, void> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSparseSharedManaged(i));
+        }
     }
 
     /// <summary>
@@ -101,15 +415,93 @@ public static void Each<T0>(Iter it, delegate*<Entity, ref T0, void> callback)
     {
         int count = it.Handle->count; Ecs.Assert(it.Handle->count > 0, "No entities returned, use Iter() or Each() without the entity argument instead.");
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0);
-        int step0 = it.Step<T0>(0);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0);
+        IterationTechnique flags = it.GetIterationTechnique(1);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0])
-            callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref Managed.GetTypeRef<T0>(pointer0));
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, delegate*<Entity, ref T0, void> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, delegate*<Entity, ref T0, void> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, delegate*<Entity, ref T0, void> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, delegate*<Entity, ref T0, void> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, delegate*<Entity, ref T0, void> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, delegate*<Entity, ref T0, void> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, delegate*<Entity, ref T0, void> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, delegate*<Entity, ref T0, void> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseSharedManaged(i));
+        }
     }
 
     /// <summary>
@@ -122,15 +514,93 @@ public static void Each<T0>(Iter it, delegate*<Iter, int, ref T0, void> callback
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0);
-        int step0 = it.Step<T0>(0);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0);
+        IterationTechnique flags = it.GetIterationTechnique(1);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0])
-            callback(it, i, ref Managed.GetTypeRef<T0>(pointer0));
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, delegate*<Iter, int, ref T0, void> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, delegate*<Iter, int, ref T0, void> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, delegate*<Iter, int, ref T0, void> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, delegate*<Iter, int, ref T0, void> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, delegate*<Iter, int, ref T0, void> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, delegate*<Iter, int, ref T0, void> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, delegate*<Iter, int, ref T0, void> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, delegate*<Iter, int, ref T0, void> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSparseSharedManaged(i));
+        }
     }
 
     /// <summary>
@@ -143,15 +613,93 @@ public static void Each<T0>(Iter it, Ecs.EachPointerCallback<T0> callback)
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0);
-        int step0 = it.Step<T0>(0);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0);
+        IterationTechnique flags = it.GetIterationTechnique(1);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0])
-            callback((T0*)pointer0);
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, Ecs.EachPointerCallback<T0> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, Ecs.EachPointerCallback<T0> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, Ecs.EachPointerCallback<T0> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, Ecs.EachPointerCallback<T0> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, Ecs.EachPointerCallback<T0> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, Ecs.EachPointerCallback<T0> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, Ecs.EachPointerCallback<T0> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, Ecs.EachPointerCallback<T0> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSparseSharedManaged(i));
+        }
     }
 
     /// <summary>
@@ -164,15 +712,93 @@ public static void Each<T0>(Iter it, Ecs.EachEntityPointerCallback<T0> callback)
     {
         int count = it.Handle->count; Ecs.Assert(it.Handle->count > 0, "No entities returned, use Iter() or Each() without the entity argument instead.");
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0);
-        int step0 = it.Step<T0>(0);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0);
+        IterationTechnique flags = it.GetIterationTechnique(1);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0])
-            callback(new Entity(it.Handle->world, it.Handle->entities[i]), (T0*)pointer0);
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, Ecs.EachEntityPointerCallback<T0> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, Ecs.EachEntityPointerCallback<T0> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, Ecs.EachEntityPointerCallback<T0> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, Ecs.EachEntityPointerCallback<T0> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, Ecs.EachEntityPointerCallback<T0> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, Ecs.EachEntityPointerCallback<T0> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, Ecs.EachEntityPointerCallback<T0> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, Ecs.EachEntityPointerCallback<T0> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseSharedManaged(i));
+        }
     }
 
     /// <summary>
@@ -185,15 +811,93 @@ public static void Each<T0>(Iter it, Ecs.EachIterPointerCallback<T0> callback)
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0);
-        int step0 = it.Step<T0>(0);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0);
+        IterationTechnique flags = it.GetIterationTechnique(1);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0])
-            callback(it, i, (T0*)pointer0);
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, Ecs.EachIterPointerCallback<T0> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, Ecs.EachIterPointerCallback<T0> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, Ecs.EachIterPointerCallback<T0> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, Ecs.EachIterPointerCallback<T0> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, Ecs.EachIterPointerCallback<T0> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, Ecs.EachIterPointerCallback<T0> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, Ecs.EachIterPointerCallback<T0> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, Ecs.EachIterPointerCallback<T0> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSparseSharedManaged(i));
+        }
     }
 
     /// <summary>
@@ -206,15 +910,93 @@ public static void Each<T0>(Iter it, delegate*<T0*, void> callback)
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0);
-        int step0 = it.Step<T0>(0);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0);
+        IterationTechnique flags = it.GetIterationTechnique(1);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0])
-            callback((T0*)pointer0);
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, delegate*<T0*, void> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, delegate*<T0*, void> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, delegate*<T0*, void> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, delegate*<T0*, void> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, delegate*<T0*, void> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, delegate*<T0*, void> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, delegate*<T0*, void> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, delegate*<T0*, void> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSparseSharedManaged(i));
+        }
     }
 
     /// <summary>
@@ -227,15 +1009,93 @@ public static void Each<T0>(Iter it, delegate*<Entity, T0*, void> callback)
     {
         int count = it.Handle->count; Ecs.Assert(it.Handle->count > 0, "No entities returned, use Iter() or Each() without the entity argument instead.");
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0);
-        int step0 = it.Step<T0>(0);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0);
+        IterationTechnique flags = it.GetIterationTechnique(1);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0])
-            callback(new Entity(it.Handle->world, it.Handle->entities[i]), (T0*)pointer0);
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, delegate*<Entity, T0*, void> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, delegate*<Entity, T0*, void> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, delegate*<Entity, T0*, void> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, delegate*<Entity, T0*, void> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, delegate*<Entity, T0*, void> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, delegate*<Entity, T0*, void> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, delegate*<Entity, T0*, void> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, delegate*<Entity, T0*, void> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseSharedManaged(i));
+        }
     }
 
     /// <summary>
@@ -248,14 +1108,92 @@ public static void Each<T0>(Iter it, delegate*<Iter, int, T0*, void> callback)
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0);
-        int step0 = it.Step<T0>(0);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0);
+        IterationTechnique flags = it.GetIterationTechnique(1);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0])
-            callback(it, i, (T0*)pointer0);
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, delegate*<Iter, int, T0*, void> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, delegate*<Iter, int, T0*, void> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, delegate*<Iter, int, T0*, void> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, delegate*<Iter, int, T0*, void> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, delegate*<Iter, int, T0*, void> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, delegate*<Iter, int, T0*, void> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, delegate*<Iter, int, T0*, void> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, delegate*<Iter, int, T0*, void> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSparseSharedManaged(i));
+        }
     }
 }
\ No newline at end of file
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/Invoker/Each/Iterator/T10.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/Invoker/Each/Iterator/T10.g.cs
index b5534e21..da7c9e0b 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/Invoker/Each/Iterator/T10.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/Invoker/Each/Iterator/T10.g.cs
@@ -1,5 +1,7 @@
 // Each/Iterator/T10.g.cs
 // File was auto-generated by /_/src/Flecs.NET.Codegen/Generators/Invoker.cs
+using System;
+using System.Runtime.CompilerServices;
 using Flecs.NET.Utilities;
 using static Flecs.NET.Bindings.flecs;
 
@@ -17,15 +19,93 @@ public static void Each<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>(Iter it, Ecs.Eac
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8); byte* pointer9 = (byte*)it.GetPointer<T9>(9);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8); int step9 = it.Step<T9>(9);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8); FieldData<T9> field9 = it.GetFieldData<T9>(9);
+        IterationTechnique flags = it.GetIterationTechnique(10);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8], pointer9 = &pointer9[step9])
-            callback(ref Managed.GetTypeRef<T0>(pointer0), ref Managed.GetTypeRef<T1>(pointer1), ref Managed.GetTypeRef<T2>(pointer2), ref Managed.GetTypeRef<T3>(pointer3), ref Managed.GetTypeRef<T4>(pointer4), ref Managed.GetTypeRef<T5>(pointer5), ref Managed.GetTypeRef<T6>(pointer6), ref Managed.GetTypeRef<T7>(pointer7), ref Managed.GetTypeRef<T8>(pointer8), ref Managed.GetTypeRef<T9>(pointer9));
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>() || RuntimeHelpers.IsReferenceOrContainsReferences<T9>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefUnmanaged(i), ref field1.RefUnmanaged(i), ref field2.RefUnmanaged(i), ref field3.RefUnmanaged(i), ref field4.RefUnmanaged(i), ref field5.RefUnmanaged(i), ref field6.RefUnmanaged(i), ref field7.RefUnmanaged(i), ref field8.RefUnmanaged(i), ref field9.RefUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSharedUnmanaged(i), ref field1.RefSharedUnmanaged(i), ref field2.RefSharedUnmanaged(i), ref field3.RefSharedUnmanaged(i), ref field4.RefSharedUnmanaged(i), ref field5.RefSharedUnmanaged(i), ref field6.RefSharedUnmanaged(i), ref field7.RefSharedUnmanaged(i), ref field8.RefSharedUnmanaged(i), ref field9.RefSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSparseUnmanaged(i), ref field1.RefSparseUnmanaged(i), ref field2.RefSparseUnmanaged(i), ref field3.RefSparseUnmanaged(i), ref field4.RefSparseUnmanaged(i), ref field5.RefSparseUnmanaged(i), ref field6.RefSparseUnmanaged(i), ref field7.RefSparseUnmanaged(i), ref field8.RefSparseUnmanaged(i), ref field9.RefSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSparseSharedUnmanaged(i), ref field1.RefSparseSharedUnmanaged(i), ref field2.RefSparseSharedUnmanaged(i), ref field3.RefSparseSharedUnmanaged(i), ref field4.RefSparseSharedUnmanaged(i), ref field5.RefSparseSharedUnmanaged(i), ref field6.RefSparseSharedUnmanaged(i), ref field7.RefSparseSharedUnmanaged(i), ref field8.RefSparseSharedUnmanaged(i), ref field9.RefSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefManaged(i), ref field1.RefManaged(i), ref field2.RefManaged(i), ref field3.RefManaged(i), ref field4.RefManaged(i), ref field5.RefManaged(i), ref field6.RefManaged(i), ref field7.RefManaged(i), ref field8.RefManaged(i), ref field9.RefManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSharedManaged(i), ref field1.RefSharedManaged(i), ref field2.RefSharedManaged(i), ref field3.RefSharedManaged(i), ref field4.RefSharedManaged(i), ref field5.RefSharedManaged(i), ref field6.RefSharedManaged(i), ref field7.RefSharedManaged(i), ref field8.RefSharedManaged(i), ref field9.RefSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSparseManaged(i), ref field1.RefSparseManaged(i), ref field2.RefSparseManaged(i), ref field3.RefSparseManaged(i), ref field4.RefSparseManaged(i), ref field5.RefSparseManaged(i), ref field6.RefSparseManaged(i), ref field7.RefSparseManaged(i), ref field8.RefSparseManaged(i), ref field9.RefSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSparseSharedManaged(i), ref field1.RefSparseSharedManaged(i), ref field2.RefSparseSharedManaged(i), ref field3.RefSparseSharedManaged(i), ref field4.RefSparseSharedManaged(i), ref field5.RefSparseSharedManaged(i), ref field6.RefSparseSharedManaged(i), ref field7.RefSparseSharedManaged(i), ref field8.RefSparseSharedManaged(i), ref field9.RefSparseSharedManaged(i));
+        }
     }
 
     /// <summary>
@@ -38,15 +118,93 @@ public static void Each<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>(Iter it, Ecs.Eac
     {
         int count = it.Handle->count; Ecs.Assert(it.Handle->count > 0, "No entities returned, use Iter() or Each() without the entity argument instead.");
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8); byte* pointer9 = (byte*)it.GetPointer<T9>(9);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8); int step9 = it.Step<T9>(9);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8); FieldData<T9> field9 = it.GetFieldData<T9>(9);
+        IterationTechnique flags = it.GetIterationTechnique(10);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8], pointer9 = &pointer9[step9])
-            callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref Managed.GetTypeRef<T0>(pointer0), ref Managed.GetTypeRef<T1>(pointer1), ref Managed.GetTypeRef<T2>(pointer2), ref Managed.GetTypeRef<T3>(pointer3), ref Managed.GetTypeRef<T4>(pointer4), ref Managed.GetTypeRef<T5>(pointer5), ref Managed.GetTypeRef<T6>(pointer6), ref Managed.GetTypeRef<T7>(pointer7), ref Managed.GetTypeRef<T8>(pointer8), ref Managed.GetTypeRef<T9>(pointer9));
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>() || RuntimeHelpers.IsReferenceOrContainsReferences<T9>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefUnmanaged(i), ref field1.RefUnmanaged(i), ref field2.RefUnmanaged(i), ref field3.RefUnmanaged(i), ref field4.RefUnmanaged(i), ref field5.RefUnmanaged(i), ref field6.RefUnmanaged(i), ref field7.RefUnmanaged(i), ref field8.RefUnmanaged(i), ref field9.RefUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSharedUnmanaged(i), ref field1.RefSharedUnmanaged(i), ref field2.RefSharedUnmanaged(i), ref field3.RefSharedUnmanaged(i), ref field4.RefSharedUnmanaged(i), ref field5.RefSharedUnmanaged(i), ref field6.RefSharedUnmanaged(i), ref field7.RefSharedUnmanaged(i), ref field8.RefSharedUnmanaged(i), ref field9.RefSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseUnmanaged(i), ref field1.RefSparseUnmanaged(i), ref field2.RefSparseUnmanaged(i), ref field3.RefSparseUnmanaged(i), ref field4.RefSparseUnmanaged(i), ref field5.RefSparseUnmanaged(i), ref field6.RefSparseUnmanaged(i), ref field7.RefSparseUnmanaged(i), ref field8.RefSparseUnmanaged(i), ref field9.RefSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseSharedUnmanaged(i), ref field1.RefSparseSharedUnmanaged(i), ref field2.RefSparseSharedUnmanaged(i), ref field3.RefSparseSharedUnmanaged(i), ref field4.RefSparseSharedUnmanaged(i), ref field5.RefSparseSharedUnmanaged(i), ref field6.RefSparseSharedUnmanaged(i), ref field7.RefSparseSharedUnmanaged(i), ref field8.RefSparseSharedUnmanaged(i), ref field9.RefSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefManaged(i), ref field1.RefManaged(i), ref field2.RefManaged(i), ref field3.RefManaged(i), ref field4.RefManaged(i), ref field5.RefManaged(i), ref field6.RefManaged(i), ref field7.RefManaged(i), ref field8.RefManaged(i), ref field9.RefManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSharedManaged(i), ref field1.RefSharedManaged(i), ref field2.RefSharedManaged(i), ref field3.RefSharedManaged(i), ref field4.RefSharedManaged(i), ref field5.RefSharedManaged(i), ref field6.RefSharedManaged(i), ref field7.RefSharedManaged(i), ref field8.RefSharedManaged(i), ref field9.RefSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseManaged(i), ref field1.RefSparseManaged(i), ref field2.RefSparseManaged(i), ref field3.RefSparseManaged(i), ref field4.RefSparseManaged(i), ref field5.RefSparseManaged(i), ref field6.RefSparseManaged(i), ref field7.RefSparseManaged(i), ref field8.RefSparseManaged(i), ref field9.RefSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseSharedManaged(i), ref field1.RefSparseSharedManaged(i), ref field2.RefSparseSharedManaged(i), ref field3.RefSparseSharedManaged(i), ref field4.RefSparseSharedManaged(i), ref field5.RefSparseSharedManaged(i), ref field6.RefSparseSharedManaged(i), ref field7.RefSparseSharedManaged(i), ref field8.RefSparseSharedManaged(i), ref field9.RefSparseSharedManaged(i));
+        }
     }
 
     /// <summary>
@@ -59,15 +217,93 @@ public static void Each<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>(Iter it, Ecs.Eac
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8); byte* pointer9 = (byte*)it.GetPointer<T9>(9);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8); int step9 = it.Step<T9>(9);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8); FieldData<T9> field9 = it.GetFieldData<T9>(9);
+        IterationTechnique flags = it.GetIterationTechnique(10);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8], pointer9 = &pointer9[step9])
-            callback(it, i, ref Managed.GetTypeRef<T0>(pointer0), ref Managed.GetTypeRef<T1>(pointer1), ref Managed.GetTypeRef<T2>(pointer2), ref Managed.GetTypeRef<T3>(pointer3), ref Managed.GetTypeRef<T4>(pointer4), ref Managed.GetTypeRef<T5>(pointer5), ref Managed.GetTypeRef<T6>(pointer6), ref Managed.GetTypeRef<T7>(pointer7), ref Managed.GetTypeRef<T8>(pointer8), ref Managed.GetTypeRef<T9>(pointer9));
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>() || RuntimeHelpers.IsReferenceOrContainsReferences<T9>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefUnmanaged(i), ref field1.RefUnmanaged(i), ref field2.RefUnmanaged(i), ref field3.RefUnmanaged(i), ref field4.RefUnmanaged(i), ref field5.RefUnmanaged(i), ref field6.RefUnmanaged(i), ref field7.RefUnmanaged(i), ref field8.RefUnmanaged(i), ref field9.RefUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSharedUnmanaged(i), ref field1.RefSharedUnmanaged(i), ref field2.RefSharedUnmanaged(i), ref field3.RefSharedUnmanaged(i), ref field4.RefSharedUnmanaged(i), ref field5.RefSharedUnmanaged(i), ref field6.RefSharedUnmanaged(i), ref field7.RefSharedUnmanaged(i), ref field8.RefSharedUnmanaged(i), ref field9.RefSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSparseUnmanaged(i), ref field1.RefSparseUnmanaged(i), ref field2.RefSparseUnmanaged(i), ref field3.RefSparseUnmanaged(i), ref field4.RefSparseUnmanaged(i), ref field5.RefSparseUnmanaged(i), ref field6.RefSparseUnmanaged(i), ref field7.RefSparseUnmanaged(i), ref field8.RefSparseUnmanaged(i), ref field9.RefSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSparseSharedUnmanaged(i), ref field1.RefSparseSharedUnmanaged(i), ref field2.RefSparseSharedUnmanaged(i), ref field3.RefSparseSharedUnmanaged(i), ref field4.RefSparseSharedUnmanaged(i), ref field5.RefSparseSharedUnmanaged(i), ref field6.RefSparseSharedUnmanaged(i), ref field7.RefSparseSharedUnmanaged(i), ref field8.RefSparseSharedUnmanaged(i), ref field9.RefSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefManaged(i), ref field1.RefManaged(i), ref field2.RefManaged(i), ref field3.RefManaged(i), ref field4.RefManaged(i), ref field5.RefManaged(i), ref field6.RefManaged(i), ref field7.RefManaged(i), ref field8.RefManaged(i), ref field9.RefManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSharedManaged(i), ref field1.RefSharedManaged(i), ref field2.RefSharedManaged(i), ref field3.RefSharedManaged(i), ref field4.RefSharedManaged(i), ref field5.RefSharedManaged(i), ref field6.RefSharedManaged(i), ref field7.RefSharedManaged(i), ref field8.RefSharedManaged(i), ref field9.RefSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSparseManaged(i), ref field1.RefSparseManaged(i), ref field2.RefSparseManaged(i), ref field3.RefSparseManaged(i), ref field4.RefSparseManaged(i), ref field5.RefSparseManaged(i), ref field6.RefSparseManaged(i), ref field7.RefSparseManaged(i), ref field8.RefSparseManaged(i), ref field9.RefSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSparseSharedManaged(i), ref field1.RefSparseSharedManaged(i), ref field2.RefSparseSharedManaged(i), ref field3.RefSparseSharedManaged(i), ref field4.RefSparseSharedManaged(i), ref field5.RefSparseSharedManaged(i), ref field6.RefSparseSharedManaged(i), ref field7.RefSparseSharedManaged(i), ref field8.RefSparseSharedManaged(i), ref field9.RefSparseSharedManaged(i));
+        }
     }
 
     /// <summary>
@@ -80,15 +316,93 @@ public static void Each<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>(Iter it, delegat
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8); byte* pointer9 = (byte*)it.GetPointer<T9>(9);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8); int step9 = it.Step<T9>(9);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8); FieldData<T9> field9 = it.GetFieldData<T9>(9);
+        IterationTechnique flags = it.GetIterationTechnique(10);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8], pointer9 = &pointer9[step9])
-            callback(ref Managed.GetTypeRef<T0>(pointer0), ref Managed.GetTypeRef<T1>(pointer1), ref Managed.GetTypeRef<T2>(pointer2), ref Managed.GetTypeRef<T3>(pointer3), ref Managed.GetTypeRef<T4>(pointer4), ref Managed.GetTypeRef<T5>(pointer5), ref Managed.GetTypeRef<T6>(pointer6), ref Managed.GetTypeRef<T7>(pointer7), ref Managed.GetTypeRef<T8>(pointer8), ref Managed.GetTypeRef<T9>(pointer9));
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>() || RuntimeHelpers.IsReferenceOrContainsReferences<T9>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefUnmanaged(i), ref field1.RefUnmanaged(i), ref field2.RefUnmanaged(i), ref field3.RefUnmanaged(i), ref field4.RefUnmanaged(i), ref field5.RefUnmanaged(i), ref field6.RefUnmanaged(i), ref field7.RefUnmanaged(i), ref field8.RefUnmanaged(i), ref field9.RefUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSharedUnmanaged(i), ref field1.RefSharedUnmanaged(i), ref field2.RefSharedUnmanaged(i), ref field3.RefSharedUnmanaged(i), ref field4.RefSharedUnmanaged(i), ref field5.RefSharedUnmanaged(i), ref field6.RefSharedUnmanaged(i), ref field7.RefSharedUnmanaged(i), ref field8.RefSharedUnmanaged(i), ref field9.RefSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSparseUnmanaged(i), ref field1.RefSparseUnmanaged(i), ref field2.RefSparseUnmanaged(i), ref field3.RefSparseUnmanaged(i), ref field4.RefSparseUnmanaged(i), ref field5.RefSparseUnmanaged(i), ref field6.RefSparseUnmanaged(i), ref field7.RefSparseUnmanaged(i), ref field8.RefSparseUnmanaged(i), ref field9.RefSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSparseSharedUnmanaged(i), ref field1.RefSparseSharedUnmanaged(i), ref field2.RefSparseSharedUnmanaged(i), ref field3.RefSparseSharedUnmanaged(i), ref field4.RefSparseSharedUnmanaged(i), ref field5.RefSparseSharedUnmanaged(i), ref field6.RefSparseSharedUnmanaged(i), ref field7.RefSparseSharedUnmanaged(i), ref field8.RefSparseSharedUnmanaged(i), ref field9.RefSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefManaged(i), ref field1.RefManaged(i), ref field2.RefManaged(i), ref field3.RefManaged(i), ref field4.RefManaged(i), ref field5.RefManaged(i), ref field6.RefManaged(i), ref field7.RefManaged(i), ref field8.RefManaged(i), ref field9.RefManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSharedManaged(i), ref field1.RefSharedManaged(i), ref field2.RefSharedManaged(i), ref field3.RefSharedManaged(i), ref field4.RefSharedManaged(i), ref field5.RefSharedManaged(i), ref field6.RefSharedManaged(i), ref field7.RefSharedManaged(i), ref field8.RefSharedManaged(i), ref field9.RefSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSparseManaged(i), ref field1.RefSparseManaged(i), ref field2.RefSparseManaged(i), ref field3.RefSparseManaged(i), ref field4.RefSparseManaged(i), ref field5.RefSparseManaged(i), ref field6.RefSparseManaged(i), ref field7.RefSparseManaged(i), ref field8.RefSparseManaged(i), ref field9.RefSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSparseSharedManaged(i), ref field1.RefSparseSharedManaged(i), ref field2.RefSparseSharedManaged(i), ref field3.RefSparseSharedManaged(i), ref field4.RefSparseSharedManaged(i), ref field5.RefSparseSharedManaged(i), ref field6.RefSparseSharedManaged(i), ref field7.RefSparseSharedManaged(i), ref field8.RefSparseSharedManaged(i), ref field9.RefSparseSharedManaged(i));
+        }
     }
 
     /// <summary>
@@ -101,15 +415,93 @@ public static void Each<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>(Iter it, delegat
     {
         int count = it.Handle->count; Ecs.Assert(it.Handle->count > 0, "No entities returned, use Iter() or Each() without the entity argument instead.");
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8); byte* pointer9 = (byte*)it.GetPointer<T9>(9);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8); int step9 = it.Step<T9>(9);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8); FieldData<T9> field9 = it.GetFieldData<T9>(9);
+        IterationTechnique flags = it.GetIterationTechnique(10);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8], pointer9 = &pointer9[step9])
-            callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref Managed.GetTypeRef<T0>(pointer0), ref Managed.GetTypeRef<T1>(pointer1), ref Managed.GetTypeRef<T2>(pointer2), ref Managed.GetTypeRef<T3>(pointer3), ref Managed.GetTypeRef<T4>(pointer4), ref Managed.GetTypeRef<T5>(pointer5), ref Managed.GetTypeRef<T6>(pointer6), ref Managed.GetTypeRef<T7>(pointer7), ref Managed.GetTypeRef<T8>(pointer8), ref Managed.GetTypeRef<T9>(pointer9));
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>() || RuntimeHelpers.IsReferenceOrContainsReferences<T9>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefUnmanaged(i), ref field1.RefUnmanaged(i), ref field2.RefUnmanaged(i), ref field3.RefUnmanaged(i), ref field4.RefUnmanaged(i), ref field5.RefUnmanaged(i), ref field6.RefUnmanaged(i), ref field7.RefUnmanaged(i), ref field8.RefUnmanaged(i), ref field9.RefUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSharedUnmanaged(i), ref field1.RefSharedUnmanaged(i), ref field2.RefSharedUnmanaged(i), ref field3.RefSharedUnmanaged(i), ref field4.RefSharedUnmanaged(i), ref field5.RefSharedUnmanaged(i), ref field6.RefSharedUnmanaged(i), ref field7.RefSharedUnmanaged(i), ref field8.RefSharedUnmanaged(i), ref field9.RefSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseUnmanaged(i), ref field1.RefSparseUnmanaged(i), ref field2.RefSparseUnmanaged(i), ref field3.RefSparseUnmanaged(i), ref field4.RefSparseUnmanaged(i), ref field5.RefSparseUnmanaged(i), ref field6.RefSparseUnmanaged(i), ref field7.RefSparseUnmanaged(i), ref field8.RefSparseUnmanaged(i), ref field9.RefSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseSharedUnmanaged(i), ref field1.RefSparseSharedUnmanaged(i), ref field2.RefSparseSharedUnmanaged(i), ref field3.RefSparseSharedUnmanaged(i), ref field4.RefSparseSharedUnmanaged(i), ref field5.RefSparseSharedUnmanaged(i), ref field6.RefSparseSharedUnmanaged(i), ref field7.RefSparseSharedUnmanaged(i), ref field8.RefSparseSharedUnmanaged(i), ref field9.RefSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefManaged(i), ref field1.RefManaged(i), ref field2.RefManaged(i), ref field3.RefManaged(i), ref field4.RefManaged(i), ref field5.RefManaged(i), ref field6.RefManaged(i), ref field7.RefManaged(i), ref field8.RefManaged(i), ref field9.RefManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSharedManaged(i), ref field1.RefSharedManaged(i), ref field2.RefSharedManaged(i), ref field3.RefSharedManaged(i), ref field4.RefSharedManaged(i), ref field5.RefSharedManaged(i), ref field6.RefSharedManaged(i), ref field7.RefSharedManaged(i), ref field8.RefSharedManaged(i), ref field9.RefSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseManaged(i), ref field1.RefSparseManaged(i), ref field2.RefSparseManaged(i), ref field3.RefSparseManaged(i), ref field4.RefSparseManaged(i), ref field5.RefSparseManaged(i), ref field6.RefSparseManaged(i), ref field7.RefSparseManaged(i), ref field8.RefSparseManaged(i), ref field9.RefSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseSharedManaged(i), ref field1.RefSparseSharedManaged(i), ref field2.RefSparseSharedManaged(i), ref field3.RefSparseSharedManaged(i), ref field4.RefSparseSharedManaged(i), ref field5.RefSparseSharedManaged(i), ref field6.RefSparseSharedManaged(i), ref field7.RefSparseSharedManaged(i), ref field8.RefSparseSharedManaged(i), ref field9.RefSparseSharedManaged(i));
+        }
     }
 
     /// <summary>
@@ -122,15 +514,93 @@ public static void Each<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>(Iter it, delegat
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8); byte* pointer9 = (byte*)it.GetPointer<T9>(9);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8); int step9 = it.Step<T9>(9);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8); FieldData<T9> field9 = it.GetFieldData<T9>(9);
+        IterationTechnique flags = it.GetIterationTechnique(10);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8], pointer9 = &pointer9[step9])
-            callback(it, i, ref Managed.GetTypeRef<T0>(pointer0), ref Managed.GetTypeRef<T1>(pointer1), ref Managed.GetTypeRef<T2>(pointer2), ref Managed.GetTypeRef<T3>(pointer3), ref Managed.GetTypeRef<T4>(pointer4), ref Managed.GetTypeRef<T5>(pointer5), ref Managed.GetTypeRef<T6>(pointer6), ref Managed.GetTypeRef<T7>(pointer7), ref Managed.GetTypeRef<T8>(pointer8), ref Managed.GetTypeRef<T9>(pointer9));
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>() || RuntimeHelpers.IsReferenceOrContainsReferences<T9>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefUnmanaged(i), ref field1.RefUnmanaged(i), ref field2.RefUnmanaged(i), ref field3.RefUnmanaged(i), ref field4.RefUnmanaged(i), ref field5.RefUnmanaged(i), ref field6.RefUnmanaged(i), ref field7.RefUnmanaged(i), ref field8.RefUnmanaged(i), ref field9.RefUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSharedUnmanaged(i), ref field1.RefSharedUnmanaged(i), ref field2.RefSharedUnmanaged(i), ref field3.RefSharedUnmanaged(i), ref field4.RefSharedUnmanaged(i), ref field5.RefSharedUnmanaged(i), ref field6.RefSharedUnmanaged(i), ref field7.RefSharedUnmanaged(i), ref field8.RefSharedUnmanaged(i), ref field9.RefSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSparseUnmanaged(i), ref field1.RefSparseUnmanaged(i), ref field2.RefSparseUnmanaged(i), ref field3.RefSparseUnmanaged(i), ref field4.RefSparseUnmanaged(i), ref field5.RefSparseUnmanaged(i), ref field6.RefSparseUnmanaged(i), ref field7.RefSparseUnmanaged(i), ref field8.RefSparseUnmanaged(i), ref field9.RefSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSparseSharedUnmanaged(i), ref field1.RefSparseSharedUnmanaged(i), ref field2.RefSparseSharedUnmanaged(i), ref field3.RefSparseSharedUnmanaged(i), ref field4.RefSparseSharedUnmanaged(i), ref field5.RefSparseSharedUnmanaged(i), ref field6.RefSparseSharedUnmanaged(i), ref field7.RefSparseSharedUnmanaged(i), ref field8.RefSparseSharedUnmanaged(i), ref field9.RefSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefManaged(i), ref field1.RefManaged(i), ref field2.RefManaged(i), ref field3.RefManaged(i), ref field4.RefManaged(i), ref field5.RefManaged(i), ref field6.RefManaged(i), ref field7.RefManaged(i), ref field8.RefManaged(i), ref field9.RefManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSharedManaged(i), ref field1.RefSharedManaged(i), ref field2.RefSharedManaged(i), ref field3.RefSharedManaged(i), ref field4.RefSharedManaged(i), ref field5.RefSharedManaged(i), ref field6.RefSharedManaged(i), ref field7.RefSharedManaged(i), ref field8.RefSharedManaged(i), ref field9.RefSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSparseManaged(i), ref field1.RefSparseManaged(i), ref field2.RefSparseManaged(i), ref field3.RefSparseManaged(i), ref field4.RefSparseManaged(i), ref field5.RefSparseManaged(i), ref field6.RefSparseManaged(i), ref field7.RefSparseManaged(i), ref field8.RefSparseManaged(i), ref field9.RefSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSparseSharedManaged(i), ref field1.RefSparseSharedManaged(i), ref field2.RefSparseSharedManaged(i), ref field3.RefSparseSharedManaged(i), ref field4.RefSparseSharedManaged(i), ref field5.RefSparseSharedManaged(i), ref field6.RefSparseSharedManaged(i), ref field7.RefSparseSharedManaged(i), ref field8.RefSparseSharedManaged(i), ref field9.RefSparseSharedManaged(i));
+        }
     }
 
     /// <summary>
@@ -143,15 +613,93 @@ public static void Each<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>(Iter it, Ecs.Eac
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8); byte* pointer9 = (byte*)it.GetPointer<T9>(9);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8); int step9 = it.Step<T9>(9);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8); FieldData<T9> field9 = it.GetFieldData<T9>(9);
+        IterationTechnique flags = it.GetIterationTechnique(10);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8], pointer9 = &pointer9[step9])
-            callback((T0*)pointer0, (T1*)pointer1, (T2*)pointer2, (T3*)pointer3, (T4*)pointer4, (T5*)pointer5, (T6*)pointer6, (T7*)pointer7, (T8*)pointer8, (T9*)pointer9);
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>() || RuntimeHelpers.IsReferenceOrContainsReferences<T9>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerUnmanaged(i), field1.PointerUnmanaged(i), field2.PointerUnmanaged(i), field3.PointerUnmanaged(i), field4.PointerUnmanaged(i), field5.PointerUnmanaged(i), field6.PointerUnmanaged(i), field7.PointerUnmanaged(i), field8.PointerUnmanaged(i), field9.PointerUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSharedUnmanaged(i), field1.PointerSharedUnmanaged(i), field2.PointerSharedUnmanaged(i), field3.PointerSharedUnmanaged(i), field4.PointerSharedUnmanaged(i), field5.PointerSharedUnmanaged(i), field6.PointerSharedUnmanaged(i), field7.PointerSharedUnmanaged(i), field8.PointerSharedUnmanaged(i), field9.PointerSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSparseUnmanaged(i), field1.PointerSparseUnmanaged(i), field2.PointerSparseUnmanaged(i), field3.PointerSparseUnmanaged(i), field4.PointerSparseUnmanaged(i), field5.PointerSparseUnmanaged(i), field6.PointerSparseUnmanaged(i), field7.PointerSparseUnmanaged(i), field8.PointerSparseUnmanaged(i), field9.PointerSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSparseSharedUnmanaged(i), field1.PointerSparseSharedUnmanaged(i), field2.PointerSparseSharedUnmanaged(i), field3.PointerSparseSharedUnmanaged(i), field4.PointerSparseSharedUnmanaged(i), field5.PointerSparseSharedUnmanaged(i), field6.PointerSparseSharedUnmanaged(i), field7.PointerSparseSharedUnmanaged(i), field8.PointerSparseSharedUnmanaged(i), field9.PointerSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerManaged(i), field1.PointerManaged(i), field2.PointerManaged(i), field3.PointerManaged(i), field4.PointerManaged(i), field5.PointerManaged(i), field6.PointerManaged(i), field7.PointerManaged(i), field8.PointerManaged(i), field9.PointerManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSharedManaged(i), field1.PointerSharedManaged(i), field2.PointerSharedManaged(i), field3.PointerSharedManaged(i), field4.PointerSharedManaged(i), field5.PointerSharedManaged(i), field6.PointerSharedManaged(i), field7.PointerSharedManaged(i), field8.PointerSharedManaged(i), field9.PointerSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSparseManaged(i), field1.PointerSparseManaged(i), field2.PointerSparseManaged(i), field3.PointerSparseManaged(i), field4.PointerSparseManaged(i), field5.PointerSparseManaged(i), field6.PointerSparseManaged(i), field7.PointerSparseManaged(i), field8.PointerSparseManaged(i), field9.PointerSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSparseSharedManaged(i), field1.PointerSparseSharedManaged(i), field2.PointerSparseSharedManaged(i), field3.PointerSparseSharedManaged(i), field4.PointerSparseSharedManaged(i), field5.PointerSparseSharedManaged(i), field6.PointerSparseSharedManaged(i), field7.PointerSparseSharedManaged(i), field8.PointerSparseSharedManaged(i), field9.PointerSparseSharedManaged(i));
+        }
     }
 
     /// <summary>
@@ -164,15 +712,93 @@ public static void Each<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>(Iter it, Ecs.Eac
     {
         int count = it.Handle->count; Ecs.Assert(it.Handle->count > 0, "No entities returned, use Iter() or Each() without the entity argument instead.");
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8); byte* pointer9 = (byte*)it.GetPointer<T9>(9);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8); int step9 = it.Step<T9>(9);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8); FieldData<T9> field9 = it.GetFieldData<T9>(9);
+        IterationTechnique flags = it.GetIterationTechnique(10);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8], pointer9 = &pointer9[step9])
-            callback(new Entity(it.Handle->world, it.Handle->entities[i]), (T0*)pointer0, (T1*)pointer1, (T2*)pointer2, (T3*)pointer3, (T4*)pointer4, (T5*)pointer5, (T6*)pointer6, (T7*)pointer7, (T8*)pointer8, (T9*)pointer9);
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>() || RuntimeHelpers.IsReferenceOrContainsReferences<T9>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerUnmanaged(i), field1.PointerUnmanaged(i), field2.PointerUnmanaged(i), field3.PointerUnmanaged(i), field4.PointerUnmanaged(i), field5.PointerUnmanaged(i), field6.PointerUnmanaged(i), field7.PointerUnmanaged(i), field8.PointerUnmanaged(i), field9.PointerUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSharedUnmanaged(i), field1.PointerSharedUnmanaged(i), field2.PointerSharedUnmanaged(i), field3.PointerSharedUnmanaged(i), field4.PointerSharedUnmanaged(i), field5.PointerSharedUnmanaged(i), field6.PointerSharedUnmanaged(i), field7.PointerSharedUnmanaged(i), field8.PointerSharedUnmanaged(i), field9.PointerSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseUnmanaged(i), field1.PointerSparseUnmanaged(i), field2.PointerSparseUnmanaged(i), field3.PointerSparseUnmanaged(i), field4.PointerSparseUnmanaged(i), field5.PointerSparseUnmanaged(i), field6.PointerSparseUnmanaged(i), field7.PointerSparseUnmanaged(i), field8.PointerSparseUnmanaged(i), field9.PointerSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseSharedUnmanaged(i), field1.PointerSparseSharedUnmanaged(i), field2.PointerSparseSharedUnmanaged(i), field3.PointerSparseSharedUnmanaged(i), field4.PointerSparseSharedUnmanaged(i), field5.PointerSparseSharedUnmanaged(i), field6.PointerSparseSharedUnmanaged(i), field7.PointerSparseSharedUnmanaged(i), field8.PointerSparseSharedUnmanaged(i), field9.PointerSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerManaged(i), field1.PointerManaged(i), field2.PointerManaged(i), field3.PointerManaged(i), field4.PointerManaged(i), field5.PointerManaged(i), field6.PointerManaged(i), field7.PointerManaged(i), field8.PointerManaged(i), field9.PointerManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSharedManaged(i), field1.PointerSharedManaged(i), field2.PointerSharedManaged(i), field3.PointerSharedManaged(i), field4.PointerSharedManaged(i), field5.PointerSharedManaged(i), field6.PointerSharedManaged(i), field7.PointerSharedManaged(i), field8.PointerSharedManaged(i), field9.PointerSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseManaged(i), field1.PointerSparseManaged(i), field2.PointerSparseManaged(i), field3.PointerSparseManaged(i), field4.PointerSparseManaged(i), field5.PointerSparseManaged(i), field6.PointerSparseManaged(i), field7.PointerSparseManaged(i), field8.PointerSparseManaged(i), field9.PointerSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseSharedManaged(i), field1.PointerSparseSharedManaged(i), field2.PointerSparseSharedManaged(i), field3.PointerSparseSharedManaged(i), field4.PointerSparseSharedManaged(i), field5.PointerSparseSharedManaged(i), field6.PointerSparseSharedManaged(i), field7.PointerSparseSharedManaged(i), field8.PointerSparseSharedManaged(i), field9.PointerSparseSharedManaged(i));
+        }
     }
 
     /// <summary>
@@ -185,15 +811,93 @@ public static void Each<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>(Iter it, Ecs.Eac
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8); byte* pointer9 = (byte*)it.GetPointer<T9>(9);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8); int step9 = it.Step<T9>(9);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8); FieldData<T9> field9 = it.GetFieldData<T9>(9);
+        IterationTechnique flags = it.GetIterationTechnique(10);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8], pointer9 = &pointer9[step9])
-            callback(it, i, (T0*)pointer0, (T1*)pointer1, (T2*)pointer2, (T3*)pointer3, (T4*)pointer4, (T5*)pointer5, (T6*)pointer6, (T7*)pointer7, (T8*)pointer8, (T9*)pointer9);
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>() || RuntimeHelpers.IsReferenceOrContainsReferences<T9>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerUnmanaged(i), field1.PointerUnmanaged(i), field2.PointerUnmanaged(i), field3.PointerUnmanaged(i), field4.PointerUnmanaged(i), field5.PointerUnmanaged(i), field6.PointerUnmanaged(i), field7.PointerUnmanaged(i), field8.PointerUnmanaged(i), field9.PointerUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSharedUnmanaged(i), field1.PointerSharedUnmanaged(i), field2.PointerSharedUnmanaged(i), field3.PointerSharedUnmanaged(i), field4.PointerSharedUnmanaged(i), field5.PointerSharedUnmanaged(i), field6.PointerSharedUnmanaged(i), field7.PointerSharedUnmanaged(i), field8.PointerSharedUnmanaged(i), field9.PointerSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSparseUnmanaged(i), field1.PointerSparseUnmanaged(i), field2.PointerSparseUnmanaged(i), field3.PointerSparseUnmanaged(i), field4.PointerSparseUnmanaged(i), field5.PointerSparseUnmanaged(i), field6.PointerSparseUnmanaged(i), field7.PointerSparseUnmanaged(i), field8.PointerSparseUnmanaged(i), field9.PointerSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSparseSharedUnmanaged(i), field1.PointerSparseSharedUnmanaged(i), field2.PointerSparseSharedUnmanaged(i), field3.PointerSparseSharedUnmanaged(i), field4.PointerSparseSharedUnmanaged(i), field5.PointerSparseSharedUnmanaged(i), field6.PointerSparseSharedUnmanaged(i), field7.PointerSparseSharedUnmanaged(i), field8.PointerSparseSharedUnmanaged(i), field9.PointerSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerManaged(i), field1.PointerManaged(i), field2.PointerManaged(i), field3.PointerManaged(i), field4.PointerManaged(i), field5.PointerManaged(i), field6.PointerManaged(i), field7.PointerManaged(i), field8.PointerManaged(i), field9.PointerManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSharedManaged(i), field1.PointerSharedManaged(i), field2.PointerSharedManaged(i), field3.PointerSharedManaged(i), field4.PointerSharedManaged(i), field5.PointerSharedManaged(i), field6.PointerSharedManaged(i), field7.PointerSharedManaged(i), field8.PointerSharedManaged(i), field9.PointerSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSparseManaged(i), field1.PointerSparseManaged(i), field2.PointerSparseManaged(i), field3.PointerSparseManaged(i), field4.PointerSparseManaged(i), field5.PointerSparseManaged(i), field6.PointerSparseManaged(i), field7.PointerSparseManaged(i), field8.PointerSparseManaged(i), field9.PointerSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSparseSharedManaged(i), field1.PointerSparseSharedManaged(i), field2.PointerSparseSharedManaged(i), field3.PointerSparseSharedManaged(i), field4.PointerSparseSharedManaged(i), field5.PointerSparseSharedManaged(i), field6.PointerSparseSharedManaged(i), field7.PointerSparseSharedManaged(i), field8.PointerSparseSharedManaged(i), field9.PointerSparseSharedManaged(i));
+        }
     }
 
     /// <summary>
@@ -206,15 +910,93 @@ public static void Each<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>(Iter it, delegat
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8); byte* pointer9 = (byte*)it.GetPointer<T9>(9);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8); int step9 = it.Step<T9>(9);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8); FieldData<T9> field9 = it.GetFieldData<T9>(9);
+        IterationTechnique flags = it.GetIterationTechnique(10);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8], pointer9 = &pointer9[step9])
-            callback((T0*)pointer0, (T1*)pointer1, (T2*)pointer2, (T3*)pointer3, (T4*)pointer4, (T5*)pointer5, (T6*)pointer6, (T7*)pointer7, (T8*)pointer8, (T9*)pointer9);
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>() || RuntimeHelpers.IsReferenceOrContainsReferences<T9>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerUnmanaged(i), field1.PointerUnmanaged(i), field2.PointerUnmanaged(i), field3.PointerUnmanaged(i), field4.PointerUnmanaged(i), field5.PointerUnmanaged(i), field6.PointerUnmanaged(i), field7.PointerUnmanaged(i), field8.PointerUnmanaged(i), field9.PointerUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSharedUnmanaged(i), field1.PointerSharedUnmanaged(i), field2.PointerSharedUnmanaged(i), field3.PointerSharedUnmanaged(i), field4.PointerSharedUnmanaged(i), field5.PointerSharedUnmanaged(i), field6.PointerSharedUnmanaged(i), field7.PointerSharedUnmanaged(i), field8.PointerSharedUnmanaged(i), field9.PointerSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSparseUnmanaged(i), field1.PointerSparseUnmanaged(i), field2.PointerSparseUnmanaged(i), field3.PointerSparseUnmanaged(i), field4.PointerSparseUnmanaged(i), field5.PointerSparseUnmanaged(i), field6.PointerSparseUnmanaged(i), field7.PointerSparseUnmanaged(i), field8.PointerSparseUnmanaged(i), field9.PointerSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSparseSharedUnmanaged(i), field1.PointerSparseSharedUnmanaged(i), field2.PointerSparseSharedUnmanaged(i), field3.PointerSparseSharedUnmanaged(i), field4.PointerSparseSharedUnmanaged(i), field5.PointerSparseSharedUnmanaged(i), field6.PointerSparseSharedUnmanaged(i), field7.PointerSparseSharedUnmanaged(i), field8.PointerSparseSharedUnmanaged(i), field9.PointerSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerManaged(i), field1.PointerManaged(i), field2.PointerManaged(i), field3.PointerManaged(i), field4.PointerManaged(i), field5.PointerManaged(i), field6.PointerManaged(i), field7.PointerManaged(i), field8.PointerManaged(i), field9.PointerManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSharedManaged(i), field1.PointerSharedManaged(i), field2.PointerSharedManaged(i), field3.PointerSharedManaged(i), field4.PointerSharedManaged(i), field5.PointerSharedManaged(i), field6.PointerSharedManaged(i), field7.PointerSharedManaged(i), field8.PointerSharedManaged(i), field9.PointerSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSparseManaged(i), field1.PointerSparseManaged(i), field2.PointerSparseManaged(i), field3.PointerSparseManaged(i), field4.PointerSparseManaged(i), field5.PointerSparseManaged(i), field6.PointerSparseManaged(i), field7.PointerSparseManaged(i), field8.PointerSparseManaged(i), field9.PointerSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSparseSharedManaged(i), field1.PointerSparseSharedManaged(i), field2.PointerSparseSharedManaged(i), field3.PointerSparseSharedManaged(i), field4.PointerSparseSharedManaged(i), field5.PointerSparseSharedManaged(i), field6.PointerSparseSharedManaged(i), field7.PointerSparseSharedManaged(i), field8.PointerSparseSharedManaged(i), field9.PointerSparseSharedManaged(i));
+        }
     }
 
     /// <summary>
@@ -227,15 +1009,93 @@ public static void Each<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>(Iter it, delegat
     {
         int count = it.Handle->count; Ecs.Assert(it.Handle->count > 0, "No entities returned, use Iter() or Each() without the entity argument instead.");
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8); byte* pointer9 = (byte*)it.GetPointer<T9>(9);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8); int step9 = it.Step<T9>(9);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8); FieldData<T9> field9 = it.GetFieldData<T9>(9);
+        IterationTechnique flags = it.GetIterationTechnique(10);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8], pointer9 = &pointer9[step9])
-            callback(new Entity(it.Handle->world, it.Handle->entities[i]), (T0*)pointer0, (T1*)pointer1, (T2*)pointer2, (T3*)pointer3, (T4*)pointer4, (T5*)pointer5, (T6*)pointer6, (T7*)pointer7, (T8*)pointer8, (T9*)pointer9);
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>() || RuntimeHelpers.IsReferenceOrContainsReferences<T9>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerUnmanaged(i), field1.PointerUnmanaged(i), field2.PointerUnmanaged(i), field3.PointerUnmanaged(i), field4.PointerUnmanaged(i), field5.PointerUnmanaged(i), field6.PointerUnmanaged(i), field7.PointerUnmanaged(i), field8.PointerUnmanaged(i), field9.PointerUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSharedUnmanaged(i), field1.PointerSharedUnmanaged(i), field2.PointerSharedUnmanaged(i), field3.PointerSharedUnmanaged(i), field4.PointerSharedUnmanaged(i), field5.PointerSharedUnmanaged(i), field6.PointerSharedUnmanaged(i), field7.PointerSharedUnmanaged(i), field8.PointerSharedUnmanaged(i), field9.PointerSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseUnmanaged(i), field1.PointerSparseUnmanaged(i), field2.PointerSparseUnmanaged(i), field3.PointerSparseUnmanaged(i), field4.PointerSparseUnmanaged(i), field5.PointerSparseUnmanaged(i), field6.PointerSparseUnmanaged(i), field7.PointerSparseUnmanaged(i), field8.PointerSparseUnmanaged(i), field9.PointerSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseSharedUnmanaged(i), field1.PointerSparseSharedUnmanaged(i), field2.PointerSparseSharedUnmanaged(i), field3.PointerSparseSharedUnmanaged(i), field4.PointerSparseSharedUnmanaged(i), field5.PointerSparseSharedUnmanaged(i), field6.PointerSparseSharedUnmanaged(i), field7.PointerSparseSharedUnmanaged(i), field8.PointerSparseSharedUnmanaged(i), field9.PointerSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerManaged(i), field1.PointerManaged(i), field2.PointerManaged(i), field3.PointerManaged(i), field4.PointerManaged(i), field5.PointerManaged(i), field6.PointerManaged(i), field7.PointerManaged(i), field8.PointerManaged(i), field9.PointerManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSharedManaged(i), field1.PointerSharedManaged(i), field2.PointerSharedManaged(i), field3.PointerSharedManaged(i), field4.PointerSharedManaged(i), field5.PointerSharedManaged(i), field6.PointerSharedManaged(i), field7.PointerSharedManaged(i), field8.PointerSharedManaged(i), field9.PointerSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseManaged(i), field1.PointerSparseManaged(i), field2.PointerSparseManaged(i), field3.PointerSparseManaged(i), field4.PointerSparseManaged(i), field5.PointerSparseManaged(i), field6.PointerSparseManaged(i), field7.PointerSparseManaged(i), field8.PointerSparseManaged(i), field9.PointerSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseSharedManaged(i), field1.PointerSparseSharedManaged(i), field2.PointerSparseSharedManaged(i), field3.PointerSparseSharedManaged(i), field4.PointerSparseSharedManaged(i), field5.PointerSparseSharedManaged(i), field6.PointerSparseSharedManaged(i), field7.PointerSparseSharedManaged(i), field8.PointerSparseSharedManaged(i), field9.PointerSparseSharedManaged(i));
+        }
     }
 
     /// <summary>
@@ -248,14 +1108,92 @@ public static void Each<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>(Iter it, delegat
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8); byte* pointer9 = (byte*)it.GetPointer<T9>(9);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8); int step9 = it.Step<T9>(9);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8); FieldData<T9> field9 = it.GetFieldData<T9>(9);
+        IterationTechnique flags = it.GetIterationTechnique(10);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8], pointer9 = &pointer9[step9])
-            callback(it, i, (T0*)pointer0, (T1*)pointer1, (T2*)pointer2, (T3*)pointer3, (T4*)pointer4, (T5*)pointer5, (T6*)pointer6, (T7*)pointer7, (T8*)pointer8, (T9*)pointer9);
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>() || RuntimeHelpers.IsReferenceOrContainsReferences<T9>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerUnmanaged(i), field1.PointerUnmanaged(i), field2.PointerUnmanaged(i), field3.PointerUnmanaged(i), field4.PointerUnmanaged(i), field5.PointerUnmanaged(i), field6.PointerUnmanaged(i), field7.PointerUnmanaged(i), field8.PointerUnmanaged(i), field9.PointerUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSharedUnmanaged(i), field1.PointerSharedUnmanaged(i), field2.PointerSharedUnmanaged(i), field3.PointerSharedUnmanaged(i), field4.PointerSharedUnmanaged(i), field5.PointerSharedUnmanaged(i), field6.PointerSharedUnmanaged(i), field7.PointerSharedUnmanaged(i), field8.PointerSharedUnmanaged(i), field9.PointerSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSparseUnmanaged(i), field1.PointerSparseUnmanaged(i), field2.PointerSparseUnmanaged(i), field3.PointerSparseUnmanaged(i), field4.PointerSparseUnmanaged(i), field5.PointerSparseUnmanaged(i), field6.PointerSparseUnmanaged(i), field7.PointerSparseUnmanaged(i), field8.PointerSparseUnmanaged(i), field9.PointerSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSparseSharedUnmanaged(i), field1.PointerSparseSharedUnmanaged(i), field2.PointerSparseSharedUnmanaged(i), field3.PointerSparseSharedUnmanaged(i), field4.PointerSparseSharedUnmanaged(i), field5.PointerSparseSharedUnmanaged(i), field6.PointerSparseSharedUnmanaged(i), field7.PointerSparseSharedUnmanaged(i), field8.PointerSparseSharedUnmanaged(i), field9.PointerSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerManaged(i), field1.PointerManaged(i), field2.PointerManaged(i), field3.PointerManaged(i), field4.PointerManaged(i), field5.PointerManaged(i), field6.PointerManaged(i), field7.PointerManaged(i), field8.PointerManaged(i), field9.PointerManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSharedManaged(i), field1.PointerSharedManaged(i), field2.PointerSharedManaged(i), field3.PointerSharedManaged(i), field4.PointerSharedManaged(i), field5.PointerSharedManaged(i), field6.PointerSharedManaged(i), field7.PointerSharedManaged(i), field8.PointerSharedManaged(i), field9.PointerSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSparseManaged(i), field1.PointerSparseManaged(i), field2.PointerSparseManaged(i), field3.PointerSparseManaged(i), field4.PointerSparseManaged(i), field5.PointerSparseManaged(i), field6.PointerSparseManaged(i), field7.PointerSparseManaged(i), field8.PointerSparseManaged(i), field9.PointerSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSparseSharedManaged(i), field1.PointerSparseSharedManaged(i), field2.PointerSparseSharedManaged(i), field3.PointerSparseSharedManaged(i), field4.PointerSparseSharedManaged(i), field5.PointerSparseSharedManaged(i), field6.PointerSparseSharedManaged(i), field7.PointerSparseSharedManaged(i), field8.PointerSparseSharedManaged(i), field9.PointerSparseSharedManaged(i));
+        }
     }
 }
\ No newline at end of file
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/Invoker/Each/Iterator/T11.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/Invoker/Each/Iterator/T11.g.cs
index 7bfc51c8..3e4c2830 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/Invoker/Each/Iterator/T11.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/Invoker/Each/Iterator/T11.g.cs
@@ -1,5 +1,7 @@
 // Each/Iterator/T11.g.cs
 // File was auto-generated by /_/src/Flecs.NET.Codegen/Generators/Invoker.cs
+using System;
+using System.Runtime.CompilerServices;
 using Flecs.NET.Utilities;
 using static Flecs.NET.Bindings.flecs;
 
@@ -17,15 +19,93 @@ public static void Each<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(Iter it, Ec
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8); byte* pointer9 = (byte*)it.GetPointer<T9>(9); byte* pointer10 = (byte*)it.GetPointer<T10>(10);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8); int step9 = it.Step<T9>(9); int step10 = it.Step<T10>(10);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8); FieldData<T9> field9 = it.GetFieldData<T9>(9); FieldData<T10> field10 = it.GetFieldData<T10>(10);
+        IterationTechnique flags = it.GetIterationTechnique(11);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8], pointer9 = &pointer9[step9], pointer10 = &pointer10[step10])
-            callback(ref Managed.GetTypeRef<T0>(pointer0), ref Managed.GetTypeRef<T1>(pointer1), ref Managed.GetTypeRef<T2>(pointer2), ref Managed.GetTypeRef<T3>(pointer3), ref Managed.GetTypeRef<T4>(pointer4), ref Managed.GetTypeRef<T5>(pointer5), ref Managed.GetTypeRef<T6>(pointer6), ref Managed.GetTypeRef<T7>(pointer7), ref Managed.GetTypeRef<T8>(pointer8), ref Managed.GetTypeRef<T9>(pointer9), ref Managed.GetTypeRef<T10>(pointer10));
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>() || RuntimeHelpers.IsReferenceOrContainsReferences<T9>() || RuntimeHelpers.IsReferenceOrContainsReferences<T10>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefUnmanaged(i), ref field1.RefUnmanaged(i), ref field2.RefUnmanaged(i), ref field3.RefUnmanaged(i), ref field4.RefUnmanaged(i), ref field5.RefUnmanaged(i), ref field6.RefUnmanaged(i), ref field7.RefUnmanaged(i), ref field8.RefUnmanaged(i), ref field9.RefUnmanaged(i), ref field10.RefUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSharedUnmanaged(i), ref field1.RefSharedUnmanaged(i), ref field2.RefSharedUnmanaged(i), ref field3.RefSharedUnmanaged(i), ref field4.RefSharedUnmanaged(i), ref field5.RefSharedUnmanaged(i), ref field6.RefSharedUnmanaged(i), ref field7.RefSharedUnmanaged(i), ref field8.RefSharedUnmanaged(i), ref field9.RefSharedUnmanaged(i), ref field10.RefSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSparseUnmanaged(i), ref field1.RefSparseUnmanaged(i), ref field2.RefSparseUnmanaged(i), ref field3.RefSparseUnmanaged(i), ref field4.RefSparseUnmanaged(i), ref field5.RefSparseUnmanaged(i), ref field6.RefSparseUnmanaged(i), ref field7.RefSparseUnmanaged(i), ref field8.RefSparseUnmanaged(i), ref field9.RefSparseUnmanaged(i), ref field10.RefSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSparseSharedUnmanaged(i), ref field1.RefSparseSharedUnmanaged(i), ref field2.RefSparseSharedUnmanaged(i), ref field3.RefSparseSharedUnmanaged(i), ref field4.RefSparseSharedUnmanaged(i), ref field5.RefSparseSharedUnmanaged(i), ref field6.RefSparseSharedUnmanaged(i), ref field7.RefSparseSharedUnmanaged(i), ref field8.RefSparseSharedUnmanaged(i), ref field9.RefSparseSharedUnmanaged(i), ref field10.RefSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefManaged(i), ref field1.RefManaged(i), ref field2.RefManaged(i), ref field3.RefManaged(i), ref field4.RefManaged(i), ref field5.RefManaged(i), ref field6.RefManaged(i), ref field7.RefManaged(i), ref field8.RefManaged(i), ref field9.RefManaged(i), ref field10.RefManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSharedManaged(i), ref field1.RefSharedManaged(i), ref field2.RefSharedManaged(i), ref field3.RefSharedManaged(i), ref field4.RefSharedManaged(i), ref field5.RefSharedManaged(i), ref field6.RefSharedManaged(i), ref field7.RefSharedManaged(i), ref field8.RefSharedManaged(i), ref field9.RefSharedManaged(i), ref field10.RefSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSparseManaged(i), ref field1.RefSparseManaged(i), ref field2.RefSparseManaged(i), ref field3.RefSparseManaged(i), ref field4.RefSparseManaged(i), ref field5.RefSparseManaged(i), ref field6.RefSparseManaged(i), ref field7.RefSparseManaged(i), ref field8.RefSparseManaged(i), ref field9.RefSparseManaged(i), ref field10.RefSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSparseSharedManaged(i), ref field1.RefSparseSharedManaged(i), ref field2.RefSparseSharedManaged(i), ref field3.RefSparseSharedManaged(i), ref field4.RefSparseSharedManaged(i), ref field5.RefSparseSharedManaged(i), ref field6.RefSparseSharedManaged(i), ref field7.RefSparseSharedManaged(i), ref field8.RefSparseSharedManaged(i), ref field9.RefSparseSharedManaged(i), ref field10.RefSparseSharedManaged(i));
+        }
     }
 
     /// <summary>
@@ -38,15 +118,93 @@ public static void Each<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(Iter it, Ec
     {
         int count = it.Handle->count; Ecs.Assert(it.Handle->count > 0, "No entities returned, use Iter() or Each() without the entity argument instead.");
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8); byte* pointer9 = (byte*)it.GetPointer<T9>(9); byte* pointer10 = (byte*)it.GetPointer<T10>(10);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8); int step9 = it.Step<T9>(9); int step10 = it.Step<T10>(10);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8); FieldData<T9> field9 = it.GetFieldData<T9>(9); FieldData<T10> field10 = it.GetFieldData<T10>(10);
+        IterationTechnique flags = it.GetIterationTechnique(11);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8], pointer9 = &pointer9[step9], pointer10 = &pointer10[step10])
-            callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref Managed.GetTypeRef<T0>(pointer0), ref Managed.GetTypeRef<T1>(pointer1), ref Managed.GetTypeRef<T2>(pointer2), ref Managed.GetTypeRef<T3>(pointer3), ref Managed.GetTypeRef<T4>(pointer4), ref Managed.GetTypeRef<T5>(pointer5), ref Managed.GetTypeRef<T6>(pointer6), ref Managed.GetTypeRef<T7>(pointer7), ref Managed.GetTypeRef<T8>(pointer8), ref Managed.GetTypeRef<T9>(pointer9), ref Managed.GetTypeRef<T10>(pointer10));
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>() || RuntimeHelpers.IsReferenceOrContainsReferences<T9>() || RuntimeHelpers.IsReferenceOrContainsReferences<T10>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefUnmanaged(i), ref field1.RefUnmanaged(i), ref field2.RefUnmanaged(i), ref field3.RefUnmanaged(i), ref field4.RefUnmanaged(i), ref field5.RefUnmanaged(i), ref field6.RefUnmanaged(i), ref field7.RefUnmanaged(i), ref field8.RefUnmanaged(i), ref field9.RefUnmanaged(i), ref field10.RefUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSharedUnmanaged(i), ref field1.RefSharedUnmanaged(i), ref field2.RefSharedUnmanaged(i), ref field3.RefSharedUnmanaged(i), ref field4.RefSharedUnmanaged(i), ref field5.RefSharedUnmanaged(i), ref field6.RefSharedUnmanaged(i), ref field7.RefSharedUnmanaged(i), ref field8.RefSharedUnmanaged(i), ref field9.RefSharedUnmanaged(i), ref field10.RefSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseUnmanaged(i), ref field1.RefSparseUnmanaged(i), ref field2.RefSparseUnmanaged(i), ref field3.RefSparseUnmanaged(i), ref field4.RefSparseUnmanaged(i), ref field5.RefSparseUnmanaged(i), ref field6.RefSparseUnmanaged(i), ref field7.RefSparseUnmanaged(i), ref field8.RefSparseUnmanaged(i), ref field9.RefSparseUnmanaged(i), ref field10.RefSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseSharedUnmanaged(i), ref field1.RefSparseSharedUnmanaged(i), ref field2.RefSparseSharedUnmanaged(i), ref field3.RefSparseSharedUnmanaged(i), ref field4.RefSparseSharedUnmanaged(i), ref field5.RefSparseSharedUnmanaged(i), ref field6.RefSparseSharedUnmanaged(i), ref field7.RefSparseSharedUnmanaged(i), ref field8.RefSparseSharedUnmanaged(i), ref field9.RefSparseSharedUnmanaged(i), ref field10.RefSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefManaged(i), ref field1.RefManaged(i), ref field2.RefManaged(i), ref field3.RefManaged(i), ref field4.RefManaged(i), ref field5.RefManaged(i), ref field6.RefManaged(i), ref field7.RefManaged(i), ref field8.RefManaged(i), ref field9.RefManaged(i), ref field10.RefManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSharedManaged(i), ref field1.RefSharedManaged(i), ref field2.RefSharedManaged(i), ref field3.RefSharedManaged(i), ref field4.RefSharedManaged(i), ref field5.RefSharedManaged(i), ref field6.RefSharedManaged(i), ref field7.RefSharedManaged(i), ref field8.RefSharedManaged(i), ref field9.RefSharedManaged(i), ref field10.RefSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseManaged(i), ref field1.RefSparseManaged(i), ref field2.RefSparseManaged(i), ref field3.RefSparseManaged(i), ref field4.RefSparseManaged(i), ref field5.RefSparseManaged(i), ref field6.RefSparseManaged(i), ref field7.RefSparseManaged(i), ref field8.RefSparseManaged(i), ref field9.RefSparseManaged(i), ref field10.RefSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseSharedManaged(i), ref field1.RefSparseSharedManaged(i), ref field2.RefSparseSharedManaged(i), ref field3.RefSparseSharedManaged(i), ref field4.RefSparseSharedManaged(i), ref field5.RefSparseSharedManaged(i), ref field6.RefSparseSharedManaged(i), ref field7.RefSparseSharedManaged(i), ref field8.RefSparseSharedManaged(i), ref field9.RefSparseSharedManaged(i), ref field10.RefSparseSharedManaged(i));
+        }
     }
 
     /// <summary>
@@ -59,15 +217,93 @@ public static void Each<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(Iter it, Ec
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8); byte* pointer9 = (byte*)it.GetPointer<T9>(9); byte* pointer10 = (byte*)it.GetPointer<T10>(10);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8); int step9 = it.Step<T9>(9); int step10 = it.Step<T10>(10);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8); FieldData<T9> field9 = it.GetFieldData<T9>(9); FieldData<T10> field10 = it.GetFieldData<T10>(10);
+        IterationTechnique flags = it.GetIterationTechnique(11);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8], pointer9 = &pointer9[step9], pointer10 = &pointer10[step10])
-            callback(it, i, ref Managed.GetTypeRef<T0>(pointer0), ref Managed.GetTypeRef<T1>(pointer1), ref Managed.GetTypeRef<T2>(pointer2), ref Managed.GetTypeRef<T3>(pointer3), ref Managed.GetTypeRef<T4>(pointer4), ref Managed.GetTypeRef<T5>(pointer5), ref Managed.GetTypeRef<T6>(pointer6), ref Managed.GetTypeRef<T7>(pointer7), ref Managed.GetTypeRef<T8>(pointer8), ref Managed.GetTypeRef<T9>(pointer9), ref Managed.GetTypeRef<T10>(pointer10));
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>() || RuntimeHelpers.IsReferenceOrContainsReferences<T9>() || RuntimeHelpers.IsReferenceOrContainsReferences<T10>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefUnmanaged(i), ref field1.RefUnmanaged(i), ref field2.RefUnmanaged(i), ref field3.RefUnmanaged(i), ref field4.RefUnmanaged(i), ref field5.RefUnmanaged(i), ref field6.RefUnmanaged(i), ref field7.RefUnmanaged(i), ref field8.RefUnmanaged(i), ref field9.RefUnmanaged(i), ref field10.RefUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSharedUnmanaged(i), ref field1.RefSharedUnmanaged(i), ref field2.RefSharedUnmanaged(i), ref field3.RefSharedUnmanaged(i), ref field4.RefSharedUnmanaged(i), ref field5.RefSharedUnmanaged(i), ref field6.RefSharedUnmanaged(i), ref field7.RefSharedUnmanaged(i), ref field8.RefSharedUnmanaged(i), ref field9.RefSharedUnmanaged(i), ref field10.RefSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSparseUnmanaged(i), ref field1.RefSparseUnmanaged(i), ref field2.RefSparseUnmanaged(i), ref field3.RefSparseUnmanaged(i), ref field4.RefSparseUnmanaged(i), ref field5.RefSparseUnmanaged(i), ref field6.RefSparseUnmanaged(i), ref field7.RefSparseUnmanaged(i), ref field8.RefSparseUnmanaged(i), ref field9.RefSparseUnmanaged(i), ref field10.RefSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSparseSharedUnmanaged(i), ref field1.RefSparseSharedUnmanaged(i), ref field2.RefSparseSharedUnmanaged(i), ref field3.RefSparseSharedUnmanaged(i), ref field4.RefSparseSharedUnmanaged(i), ref field5.RefSparseSharedUnmanaged(i), ref field6.RefSparseSharedUnmanaged(i), ref field7.RefSparseSharedUnmanaged(i), ref field8.RefSparseSharedUnmanaged(i), ref field9.RefSparseSharedUnmanaged(i), ref field10.RefSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefManaged(i), ref field1.RefManaged(i), ref field2.RefManaged(i), ref field3.RefManaged(i), ref field4.RefManaged(i), ref field5.RefManaged(i), ref field6.RefManaged(i), ref field7.RefManaged(i), ref field8.RefManaged(i), ref field9.RefManaged(i), ref field10.RefManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSharedManaged(i), ref field1.RefSharedManaged(i), ref field2.RefSharedManaged(i), ref field3.RefSharedManaged(i), ref field4.RefSharedManaged(i), ref field5.RefSharedManaged(i), ref field6.RefSharedManaged(i), ref field7.RefSharedManaged(i), ref field8.RefSharedManaged(i), ref field9.RefSharedManaged(i), ref field10.RefSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSparseManaged(i), ref field1.RefSparseManaged(i), ref field2.RefSparseManaged(i), ref field3.RefSparseManaged(i), ref field4.RefSparseManaged(i), ref field5.RefSparseManaged(i), ref field6.RefSparseManaged(i), ref field7.RefSparseManaged(i), ref field8.RefSparseManaged(i), ref field9.RefSparseManaged(i), ref field10.RefSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSparseSharedManaged(i), ref field1.RefSparseSharedManaged(i), ref field2.RefSparseSharedManaged(i), ref field3.RefSparseSharedManaged(i), ref field4.RefSparseSharedManaged(i), ref field5.RefSparseSharedManaged(i), ref field6.RefSparseSharedManaged(i), ref field7.RefSparseSharedManaged(i), ref field8.RefSparseSharedManaged(i), ref field9.RefSparseSharedManaged(i), ref field10.RefSparseSharedManaged(i));
+        }
     }
 
     /// <summary>
@@ -80,15 +316,93 @@ public static void Each<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(Iter it, de
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8); byte* pointer9 = (byte*)it.GetPointer<T9>(9); byte* pointer10 = (byte*)it.GetPointer<T10>(10);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8); int step9 = it.Step<T9>(9); int step10 = it.Step<T10>(10);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8); FieldData<T9> field9 = it.GetFieldData<T9>(9); FieldData<T10> field10 = it.GetFieldData<T10>(10);
+        IterationTechnique flags = it.GetIterationTechnique(11);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8], pointer9 = &pointer9[step9], pointer10 = &pointer10[step10])
-            callback(ref Managed.GetTypeRef<T0>(pointer0), ref Managed.GetTypeRef<T1>(pointer1), ref Managed.GetTypeRef<T2>(pointer2), ref Managed.GetTypeRef<T3>(pointer3), ref Managed.GetTypeRef<T4>(pointer4), ref Managed.GetTypeRef<T5>(pointer5), ref Managed.GetTypeRef<T6>(pointer6), ref Managed.GetTypeRef<T7>(pointer7), ref Managed.GetTypeRef<T8>(pointer8), ref Managed.GetTypeRef<T9>(pointer9), ref Managed.GetTypeRef<T10>(pointer10));
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>() || RuntimeHelpers.IsReferenceOrContainsReferences<T9>() || RuntimeHelpers.IsReferenceOrContainsReferences<T10>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefUnmanaged(i), ref field1.RefUnmanaged(i), ref field2.RefUnmanaged(i), ref field3.RefUnmanaged(i), ref field4.RefUnmanaged(i), ref field5.RefUnmanaged(i), ref field6.RefUnmanaged(i), ref field7.RefUnmanaged(i), ref field8.RefUnmanaged(i), ref field9.RefUnmanaged(i), ref field10.RefUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSharedUnmanaged(i), ref field1.RefSharedUnmanaged(i), ref field2.RefSharedUnmanaged(i), ref field3.RefSharedUnmanaged(i), ref field4.RefSharedUnmanaged(i), ref field5.RefSharedUnmanaged(i), ref field6.RefSharedUnmanaged(i), ref field7.RefSharedUnmanaged(i), ref field8.RefSharedUnmanaged(i), ref field9.RefSharedUnmanaged(i), ref field10.RefSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSparseUnmanaged(i), ref field1.RefSparseUnmanaged(i), ref field2.RefSparseUnmanaged(i), ref field3.RefSparseUnmanaged(i), ref field4.RefSparseUnmanaged(i), ref field5.RefSparseUnmanaged(i), ref field6.RefSparseUnmanaged(i), ref field7.RefSparseUnmanaged(i), ref field8.RefSparseUnmanaged(i), ref field9.RefSparseUnmanaged(i), ref field10.RefSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSparseSharedUnmanaged(i), ref field1.RefSparseSharedUnmanaged(i), ref field2.RefSparseSharedUnmanaged(i), ref field3.RefSparseSharedUnmanaged(i), ref field4.RefSparseSharedUnmanaged(i), ref field5.RefSparseSharedUnmanaged(i), ref field6.RefSparseSharedUnmanaged(i), ref field7.RefSparseSharedUnmanaged(i), ref field8.RefSparseSharedUnmanaged(i), ref field9.RefSparseSharedUnmanaged(i), ref field10.RefSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefManaged(i), ref field1.RefManaged(i), ref field2.RefManaged(i), ref field3.RefManaged(i), ref field4.RefManaged(i), ref field5.RefManaged(i), ref field6.RefManaged(i), ref field7.RefManaged(i), ref field8.RefManaged(i), ref field9.RefManaged(i), ref field10.RefManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSharedManaged(i), ref field1.RefSharedManaged(i), ref field2.RefSharedManaged(i), ref field3.RefSharedManaged(i), ref field4.RefSharedManaged(i), ref field5.RefSharedManaged(i), ref field6.RefSharedManaged(i), ref field7.RefSharedManaged(i), ref field8.RefSharedManaged(i), ref field9.RefSharedManaged(i), ref field10.RefSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSparseManaged(i), ref field1.RefSparseManaged(i), ref field2.RefSparseManaged(i), ref field3.RefSparseManaged(i), ref field4.RefSparseManaged(i), ref field5.RefSparseManaged(i), ref field6.RefSparseManaged(i), ref field7.RefSparseManaged(i), ref field8.RefSparseManaged(i), ref field9.RefSparseManaged(i), ref field10.RefSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSparseSharedManaged(i), ref field1.RefSparseSharedManaged(i), ref field2.RefSparseSharedManaged(i), ref field3.RefSparseSharedManaged(i), ref field4.RefSparseSharedManaged(i), ref field5.RefSparseSharedManaged(i), ref field6.RefSparseSharedManaged(i), ref field7.RefSparseSharedManaged(i), ref field8.RefSparseSharedManaged(i), ref field9.RefSparseSharedManaged(i), ref field10.RefSparseSharedManaged(i));
+        }
     }
 
     /// <summary>
@@ -101,15 +415,93 @@ public static void Each<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(Iter it, de
     {
         int count = it.Handle->count; Ecs.Assert(it.Handle->count > 0, "No entities returned, use Iter() or Each() without the entity argument instead.");
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8); byte* pointer9 = (byte*)it.GetPointer<T9>(9); byte* pointer10 = (byte*)it.GetPointer<T10>(10);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8); int step9 = it.Step<T9>(9); int step10 = it.Step<T10>(10);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8); FieldData<T9> field9 = it.GetFieldData<T9>(9); FieldData<T10> field10 = it.GetFieldData<T10>(10);
+        IterationTechnique flags = it.GetIterationTechnique(11);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8], pointer9 = &pointer9[step9], pointer10 = &pointer10[step10])
-            callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref Managed.GetTypeRef<T0>(pointer0), ref Managed.GetTypeRef<T1>(pointer1), ref Managed.GetTypeRef<T2>(pointer2), ref Managed.GetTypeRef<T3>(pointer3), ref Managed.GetTypeRef<T4>(pointer4), ref Managed.GetTypeRef<T5>(pointer5), ref Managed.GetTypeRef<T6>(pointer6), ref Managed.GetTypeRef<T7>(pointer7), ref Managed.GetTypeRef<T8>(pointer8), ref Managed.GetTypeRef<T9>(pointer9), ref Managed.GetTypeRef<T10>(pointer10));
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>() || RuntimeHelpers.IsReferenceOrContainsReferences<T9>() || RuntimeHelpers.IsReferenceOrContainsReferences<T10>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefUnmanaged(i), ref field1.RefUnmanaged(i), ref field2.RefUnmanaged(i), ref field3.RefUnmanaged(i), ref field4.RefUnmanaged(i), ref field5.RefUnmanaged(i), ref field6.RefUnmanaged(i), ref field7.RefUnmanaged(i), ref field8.RefUnmanaged(i), ref field9.RefUnmanaged(i), ref field10.RefUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSharedUnmanaged(i), ref field1.RefSharedUnmanaged(i), ref field2.RefSharedUnmanaged(i), ref field3.RefSharedUnmanaged(i), ref field4.RefSharedUnmanaged(i), ref field5.RefSharedUnmanaged(i), ref field6.RefSharedUnmanaged(i), ref field7.RefSharedUnmanaged(i), ref field8.RefSharedUnmanaged(i), ref field9.RefSharedUnmanaged(i), ref field10.RefSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseUnmanaged(i), ref field1.RefSparseUnmanaged(i), ref field2.RefSparseUnmanaged(i), ref field3.RefSparseUnmanaged(i), ref field4.RefSparseUnmanaged(i), ref field5.RefSparseUnmanaged(i), ref field6.RefSparseUnmanaged(i), ref field7.RefSparseUnmanaged(i), ref field8.RefSparseUnmanaged(i), ref field9.RefSparseUnmanaged(i), ref field10.RefSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseSharedUnmanaged(i), ref field1.RefSparseSharedUnmanaged(i), ref field2.RefSparseSharedUnmanaged(i), ref field3.RefSparseSharedUnmanaged(i), ref field4.RefSparseSharedUnmanaged(i), ref field5.RefSparseSharedUnmanaged(i), ref field6.RefSparseSharedUnmanaged(i), ref field7.RefSparseSharedUnmanaged(i), ref field8.RefSparseSharedUnmanaged(i), ref field9.RefSparseSharedUnmanaged(i), ref field10.RefSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefManaged(i), ref field1.RefManaged(i), ref field2.RefManaged(i), ref field3.RefManaged(i), ref field4.RefManaged(i), ref field5.RefManaged(i), ref field6.RefManaged(i), ref field7.RefManaged(i), ref field8.RefManaged(i), ref field9.RefManaged(i), ref field10.RefManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSharedManaged(i), ref field1.RefSharedManaged(i), ref field2.RefSharedManaged(i), ref field3.RefSharedManaged(i), ref field4.RefSharedManaged(i), ref field5.RefSharedManaged(i), ref field6.RefSharedManaged(i), ref field7.RefSharedManaged(i), ref field8.RefSharedManaged(i), ref field9.RefSharedManaged(i), ref field10.RefSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseManaged(i), ref field1.RefSparseManaged(i), ref field2.RefSparseManaged(i), ref field3.RefSparseManaged(i), ref field4.RefSparseManaged(i), ref field5.RefSparseManaged(i), ref field6.RefSparseManaged(i), ref field7.RefSparseManaged(i), ref field8.RefSparseManaged(i), ref field9.RefSparseManaged(i), ref field10.RefSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseSharedManaged(i), ref field1.RefSparseSharedManaged(i), ref field2.RefSparseSharedManaged(i), ref field3.RefSparseSharedManaged(i), ref field4.RefSparseSharedManaged(i), ref field5.RefSparseSharedManaged(i), ref field6.RefSparseSharedManaged(i), ref field7.RefSparseSharedManaged(i), ref field8.RefSparseSharedManaged(i), ref field9.RefSparseSharedManaged(i), ref field10.RefSparseSharedManaged(i));
+        }
     }
 
     /// <summary>
@@ -122,15 +514,93 @@ public static void Each<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(Iter it, de
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8); byte* pointer9 = (byte*)it.GetPointer<T9>(9); byte* pointer10 = (byte*)it.GetPointer<T10>(10);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8); int step9 = it.Step<T9>(9); int step10 = it.Step<T10>(10);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8); FieldData<T9> field9 = it.GetFieldData<T9>(9); FieldData<T10> field10 = it.GetFieldData<T10>(10);
+        IterationTechnique flags = it.GetIterationTechnique(11);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8], pointer9 = &pointer9[step9], pointer10 = &pointer10[step10])
-            callback(it, i, ref Managed.GetTypeRef<T0>(pointer0), ref Managed.GetTypeRef<T1>(pointer1), ref Managed.GetTypeRef<T2>(pointer2), ref Managed.GetTypeRef<T3>(pointer3), ref Managed.GetTypeRef<T4>(pointer4), ref Managed.GetTypeRef<T5>(pointer5), ref Managed.GetTypeRef<T6>(pointer6), ref Managed.GetTypeRef<T7>(pointer7), ref Managed.GetTypeRef<T8>(pointer8), ref Managed.GetTypeRef<T9>(pointer9), ref Managed.GetTypeRef<T10>(pointer10));
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>() || RuntimeHelpers.IsReferenceOrContainsReferences<T9>() || RuntimeHelpers.IsReferenceOrContainsReferences<T10>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefUnmanaged(i), ref field1.RefUnmanaged(i), ref field2.RefUnmanaged(i), ref field3.RefUnmanaged(i), ref field4.RefUnmanaged(i), ref field5.RefUnmanaged(i), ref field6.RefUnmanaged(i), ref field7.RefUnmanaged(i), ref field8.RefUnmanaged(i), ref field9.RefUnmanaged(i), ref field10.RefUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSharedUnmanaged(i), ref field1.RefSharedUnmanaged(i), ref field2.RefSharedUnmanaged(i), ref field3.RefSharedUnmanaged(i), ref field4.RefSharedUnmanaged(i), ref field5.RefSharedUnmanaged(i), ref field6.RefSharedUnmanaged(i), ref field7.RefSharedUnmanaged(i), ref field8.RefSharedUnmanaged(i), ref field9.RefSharedUnmanaged(i), ref field10.RefSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSparseUnmanaged(i), ref field1.RefSparseUnmanaged(i), ref field2.RefSparseUnmanaged(i), ref field3.RefSparseUnmanaged(i), ref field4.RefSparseUnmanaged(i), ref field5.RefSparseUnmanaged(i), ref field6.RefSparseUnmanaged(i), ref field7.RefSparseUnmanaged(i), ref field8.RefSparseUnmanaged(i), ref field9.RefSparseUnmanaged(i), ref field10.RefSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSparseSharedUnmanaged(i), ref field1.RefSparseSharedUnmanaged(i), ref field2.RefSparseSharedUnmanaged(i), ref field3.RefSparseSharedUnmanaged(i), ref field4.RefSparseSharedUnmanaged(i), ref field5.RefSparseSharedUnmanaged(i), ref field6.RefSparseSharedUnmanaged(i), ref field7.RefSparseSharedUnmanaged(i), ref field8.RefSparseSharedUnmanaged(i), ref field9.RefSparseSharedUnmanaged(i), ref field10.RefSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefManaged(i), ref field1.RefManaged(i), ref field2.RefManaged(i), ref field3.RefManaged(i), ref field4.RefManaged(i), ref field5.RefManaged(i), ref field6.RefManaged(i), ref field7.RefManaged(i), ref field8.RefManaged(i), ref field9.RefManaged(i), ref field10.RefManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSharedManaged(i), ref field1.RefSharedManaged(i), ref field2.RefSharedManaged(i), ref field3.RefSharedManaged(i), ref field4.RefSharedManaged(i), ref field5.RefSharedManaged(i), ref field6.RefSharedManaged(i), ref field7.RefSharedManaged(i), ref field8.RefSharedManaged(i), ref field9.RefSharedManaged(i), ref field10.RefSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSparseManaged(i), ref field1.RefSparseManaged(i), ref field2.RefSparseManaged(i), ref field3.RefSparseManaged(i), ref field4.RefSparseManaged(i), ref field5.RefSparseManaged(i), ref field6.RefSparseManaged(i), ref field7.RefSparseManaged(i), ref field8.RefSparseManaged(i), ref field9.RefSparseManaged(i), ref field10.RefSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSparseSharedManaged(i), ref field1.RefSparseSharedManaged(i), ref field2.RefSparseSharedManaged(i), ref field3.RefSparseSharedManaged(i), ref field4.RefSparseSharedManaged(i), ref field5.RefSparseSharedManaged(i), ref field6.RefSparseSharedManaged(i), ref field7.RefSparseSharedManaged(i), ref field8.RefSparseSharedManaged(i), ref field9.RefSparseSharedManaged(i), ref field10.RefSparseSharedManaged(i));
+        }
     }
 
     /// <summary>
@@ -143,15 +613,93 @@ public static void Each<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(Iter it, Ec
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8); byte* pointer9 = (byte*)it.GetPointer<T9>(9); byte* pointer10 = (byte*)it.GetPointer<T10>(10);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8); int step9 = it.Step<T9>(9); int step10 = it.Step<T10>(10);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8); FieldData<T9> field9 = it.GetFieldData<T9>(9); FieldData<T10> field10 = it.GetFieldData<T10>(10);
+        IterationTechnique flags = it.GetIterationTechnique(11);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8], pointer9 = &pointer9[step9], pointer10 = &pointer10[step10])
-            callback((T0*)pointer0, (T1*)pointer1, (T2*)pointer2, (T3*)pointer3, (T4*)pointer4, (T5*)pointer5, (T6*)pointer6, (T7*)pointer7, (T8*)pointer8, (T9*)pointer9, (T10*)pointer10);
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>() || RuntimeHelpers.IsReferenceOrContainsReferences<T9>() || RuntimeHelpers.IsReferenceOrContainsReferences<T10>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerUnmanaged(i), field1.PointerUnmanaged(i), field2.PointerUnmanaged(i), field3.PointerUnmanaged(i), field4.PointerUnmanaged(i), field5.PointerUnmanaged(i), field6.PointerUnmanaged(i), field7.PointerUnmanaged(i), field8.PointerUnmanaged(i), field9.PointerUnmanaged(i), field10.PointerUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSharedUnmanaged(i), field1.PointerSharedUnmanaged(i), field2.PointerSharedUnmanaged(i), field3.PointerSharedUnmanaged(i), field4.PointerSharedUnmanaged(i), field5.PointerSharedUnmanaged(i), field6.PointerSharedUnmanaged(i), field7.PointerSharedUnmanaged(i), field8.PointerSharedUnmanaged(i), field9.PointerSharedUnmanaged(i), field10.PointerSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSparseUnmanaged(i), field1.PointerSparseUnmanaged(i), field2.PointerSparseUnmanaged(i), field3.PointerSparseUnmanaged(i), field4.PointerSparseUnmanaged(i), field5.PointerSparseUnmanaged(i), field6.PointerSparseUnmanaged(i), field7.PointerSparseUnmanaged(i), field8.PointerSparseUnmanaged(i), field9.PointerSparseUnmanaged(i), field10.PointerSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSparseSharedUnmanaged(i), field1.PointerSparseSharedUnmanaged(i), field2.PointerSparseSharedUnmanaged(i), field3.PointerSparseSharedUnmanaged(i), field4.PointerSparseSharedUnmanaged(i), field5.PointerSparseSharedUnmanaged(i), field6.PointerSparseSharedUnmanaged(i), field7.PointerSparseSharedUnmanaged(i), field8.PointerSparseSharedUnmanaged(i), field9.PointerSparseSharedUnmanaged(i), field10.PointerSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerManaged(i), field1.PointerManaged(i), field2.PointerManaged(i), field3.PointerManaged(i), field4.PointerManaged(i), field5.PointerManaged(i), field6.PointerManaged(i), field7.PointerManaged(i), field8.PointerManaged(i), field9.PointerManaged(i), field10.PointerManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSharedManaged(i), field1.PointerSharedManaged(i), field2.PointerSharedManaged(i), field3.PointerSharedManaged(i), field4.PointerSharedManaged(i), field5.PointerSharedManaged(i), field6.PointerSharedManaged(i), field7.PointerSharedManaged(i), field8.PointerSharedManaged(i), field9.PointerSharedManaged(i), field10.PointerSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSparseManaged(i), field1.PointerSparseManaged(i), field2.PointerSparseManaged(i), field3.PointerSparseManaged(i), field4.PointerSparseManaged(i), field5.PointerSparseManaged(i), field6.PointerSparseManaged(i), field7.PointerSparseManaged(i), field8.PointerSparseManaged(i), field9.PointerSparseManaged(i), field10.PointerSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSparseSharedManaged(i), field1.PointerSparseSharedManaged(i), field2.PointerSparseSharedManaged(i), field3.PointerSparseSharedManaged(i), field4.PointerSparseSharedManaged(i), field5.PointerSparseSharedManaged(i), field6.PointerSparseSharedManaged(i), field7.PointerSparseSharedManaged(i), field8.PointerSparseSharedManaged(i), field9.PointerSparseSharedManaged(i), field10.PointerSparseSharedManaged(i));
+        }
     }
 
     /// <summary>
@@ -164,15 +712,93 @@ public static void Each<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(Iter it, Ec
     {
         int count = it.Handle->count; Ecs.Assert(it.Handle->count > 0, "No entities returned, use Iter() or Each() without the entity argument instead.");
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8); byte* pointer9 = (byte*)it.GetPointer<T9>(9); byte* pointer10 = (byte*)it.GetPointer<T10>(10);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8); int step9 = it.Step<T9>(9); int step10 = it.Step<T10>(10);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8); FieldData<T9> field9 = it.GetFieldData<T9>(9); FieldData<T10> field10 = it.GetFieldData<T10>(10);
+        IterationTechnique flags = it.GetIterationTechnique(11);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8], pointer9 = &pointer9[step9], pointer10 = &pointer10[step10])
-            callback(new Entity(it.Handle->world, it.Handle->entities[i]), (T0*)pointer0, (T1*)pointer1, (T2*)pointer2, (T3*)pointer3, (T4*)pointer4, (T5*)pointer5, (T6*)pointer6, (T7*)pointer7, (T8*)pointer8, (T9*)pointer9, (T10*)pointer10);
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>() || RuntimeHelpers.IsReferenceOrContainsReferences<T9>() || RuntimeHelpers.IsReferenceOrContainsReferences<T10>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerUnmanaged(i), field1.PointerUnmanaged(i), field2.PointerUnmanaged(i), field3.PointerUnmanaged(i), field4.PointerUnmanaged(i), field5.PointerUnmanaged(i), field6.PointerUnmanaged(i), field7.PointerUnmanaged(i), field8.PointerUnmanaged(i), field9.PointerUnmanaged(i), field10.PointerUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSharedUnmanaged(i), field1.PointerSharedUnmanaged(i), field2.PointerSharedUnmanaged(i), field3.PointerSharedUnmanaged(i), field4.PointerSharedUnmanaged(i), field5.PointerSharedUnmanaged(i), field6.PointerSharedUnmanaged(i), field7.PointerSharedUnmanaged(i), field8.PointerSharedUnmanaged(i), field9.PointerSharedUnmanaged(i), field10.PointerSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseUnmanaged(i), field1.PointerSparseUnmanaged(i), field2.PointerSparseUnmanaged(i), field3.PointerSparseUnmanaged(i), field4.PointerSparseUnmanaged(i), field5.PointerSparseUnmanaged(i), field6.PointerSparseUnmanaged(i), field7.PointerSparseUnmanaged(i), field8.PointerSparseUnmanaged(i), field9.PointerSparseUnmanaged(i), field10.PointerSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseSharedUnmanaged(i), field1.PointerSparseSharedUnmanaged(i), field2.PointerSparseSharedUnmanaged(i), field3.PointerSparseSharedUnmanaged(i), field4.PointerSparseSharedUnmanaged(i), field5.PointerSparseSharedUnmanaged(i), field6.PointerSparseSharedUnmanaged(i), field7.PointerSparseSharedUnmanaged(i), field8.PointerSparseSharedUnmanaged(i), field9.PointerSparseSharedUnmanaged(i), field10.PointerSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerManaged(i), field1.PointerManaged(i), field2.PointerManaged(i), field3.PointerManaged(i), field4.PointerManaged(i), field5.PointerManaged(i), field6.PointerManaged(i), field7.PointerManaged(i), field8.PointerManaged(i), field9.PointerManaged(i), field10.PointerManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSharedManaged(i), field1.PointerSharedManaged(i), field2.PointerSharedManaged(i), field3.PointerSharedManaged(i), field4.PointerSharedManaged(i), field5.PointerSharedManaged(i), field6.PointerSharedManaged(i), field7.PointerSharedManaged(i), field8.PointerSharedManaged(i), field9.PointerSharedManaged(i), field10.PointerSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseManaged(i), field1.PointerSparseManaged(i), field2.PointerSparseManaged(i), field3.PointerSparseManaged(i), field4.PointerSparseManaged(i), field5.PointerSparseManaged(i), field6.PointerSparseManaged(i), field7.PointerSparseManaged(i), field8.PointerSparseManaged(i), field9.PointerSparseManaged(i), field10.PointerSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseSharedManaged(i), field1.PointerSparseSharedManaged(i), field2.PointerSparseSharedManaged(i), field3.PointerSparseSharedManaged(i), field4.PointerSparseSharedManaged(i), field5.PointerSparseSharedManaged(i), field6.PointerSparseSharedManaged(i), field7.PointerSparseSharedManaged(i), field8.PointerSparseSharedManaged(i), field9.PointerSparseSharedManaged(i), field10.PointerSparseSharedManaged(i));
+        }
     }
 
     /// <summary>
@@ -185,15 +811,93 @@ public static void Each<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(Iter it, Ec
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8); byte* pointer9 = (byte*)it.GetPointer<T9>(9); byte* pointer10 = (byte*)it.GetPointer<T10>(10);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8); int step9 = it.Step<T9>(9); int step10 = it.Step<T10>(10);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8); FieldData<T9> field9 = it.GetFieldData<T9>(9); FieldData<T10> field10 = it.GetFieldData<T10>(10);
+        IterationTechnique flags = it.GetIterationTechnique(11);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8], pointer9 = &pointer9[step9], pointer10 = &pointer10[step10])
-            callback(it, i, (T0*)pointer0, (T1*)pointer1, (T2*)pointer2, (T3*)pointer3, (T4*)pointer4, (T5*)pointer5, (T6*)pointer6, (T7*)pointer7, (T8*)pointer8, (T9*)pointer9, (T10*)pointer10);
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>() || RuntimeHelpers.IsReferenceOrContainsReferences<T9>() || RuntimeHelpers.IsReferenceOrContainsReferences<T10>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerUnmanaged(i), field1.PointerUnmanaged(i), field2.PointerUnmanaged(i), field3.PointerUnmanaged(i), field4.PointerUnmanaged(i), field5.PointerUnmanaged(i), field6.PointerUnmanaged(i), field7.PointerUnmanaged(i), field8.PointerUnmanaged(i), field9.PointerUnmanaged(i), field10.PointerUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSharedUnmanaged(i), field1.PointerSharedUnmanaged(i), field2.PointerSharedUnmanaged(i), field3.PointerSharedUnmanaged(i), field4.PointerSharedUnmanaged(i), field5.PointerSharedUnmanaged(i), field6.PointerSharedUnmanaged(i), field7.PointerSharedUnmanaged(i), field8.PointerSharedUnmanaged(i), field9.PointerSharedUnmanaged(i), field10.PointerSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSparseUnmanaged(i), field1.PointerSparseUnmanaged(i), field2.PointerSparseUnmanaged(i), field3.PointerSparseUnmanaged(i), field4.PointerSparseUnmanaged(i), field5.PointerSparseUnmanaged(i), field6.PointerSparseUnmanaged(i), field7.PointerSparseUnmanaged(i), field8.PointerSparseUnmanaged(i), field9.PointerSparseUnmanaged(i), field10.PointerSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSparseSharedUnmanaged(i), field1.PointerSparseSharedUnmanaged(i), field2.PointerSparseSharedUnmanaged(i), field3.PointerSparseSharedUnmanaged(i), field4.PointerSparseSharedUnmanaged(i), field5.PointerSparseSharedUnmanaged(i), field6.PointerSparseSharedUnmanaged(i), field7.PointerSparseSharedUnmanaged(i), field8.PointerSparseSharedUnmanaged(i), field9.PointerSparseSharedUnmanaged(i), field10.PointerSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerManaged(i), field1.PointerManaged(i), field2.PointerManaged(i), field3.PointerManaged(i), field4.PointerManaged(i), field5.PointerManaged(i), field6.PointerManaged(i), field7.PointerManaged(i), field8.PointerManaged(i), field9.PointerManaged(i), field10.PointerManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSharedManaged(i), field1.PointerSharedManaged(i), field2.PointerSharedManaged(i), field3.PointerSharedManaged(i), field4.PointerSharedManaged(i), field5.PointerSharedManaged(i), field6.PointerSharedManaged(i), field7.PointerSharedManaged(i), field8.PointerSharedManaged(i), field9.PointerSharedManaged(i), field10.PointerSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSparseManaged(i), field1.PointerSparseManaged(i), field2.PointerSparseManaged(i), field3.PointerSparseManaged(i), field4.PointerSparseManaged(i), field5.PointerSparseManaged(i), field6.PointerSparseManaged(i), field7.PointerSparseManaged(i), field8.PointerSparseManaged(i), field9.PointerSparseManaged(i), field10.PointerSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSparseSharedManaged(i), field1.PointerSparseSharedManaged(i), field2.PointerSparseSharedManaged(i), field3.PointerSparseSharedManaged(i), field4.PointerSparseSharedManaged(i), field5.PointerSparseSharedManaged(i), field6.PointerSparseSharedManaged(i), field7.PointerSparseSharedManaged(i), field8.PointerSparseSharedManaged(i), field9.PointerSparseSharedManaged(i), field10.PointerSparseSharedManaged(i));
+        }
     }
 
     /// <summary>
@@ -206,15 +910,93 @@ public static void Each<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(Iter it, de
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8); byte* pointer9 = (byte*)it.GetPointer<T9>(9); byte* pointer10 = (byte*)it.GetPointer<T10>(10);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8); int step9 = it.Step<T9>(9); int step10 = it.Step<T10>(10);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8); FieldData<T9> field9 = it.GetFieldData<T9>(9); FieldData<T10> field10 = it.GetFieldData<T10>(10);
+        IterationTechnique flags = it.GetIterationTechnique(11);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8], pointer9 = &pointer9[step9], pointer10 = &pointer10[step10])
-            callback((T0*)pointer0, (T1*)pointer1, (T2*)pointer2, (T3*)pointer3, (T4*)pointer4, (T5*)pointer5, (T6*)pointer6, (T7*)pointer7, (T8*)pointer8, (T9*)pointer9, (T10*)pointer10);
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>() || RuntimeHelpers.IsReferenceOrContainsReferences<T9>() || RuntimeHelpers.IsReferenceOrContainsReferences<T10>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerUnmanaged(i), field1.PointerUnmanaged(i), field2.PointerUnmanaged(i), field3.PointerUnmanaged(i), field4.PointerUnmanaged(i), field5.PointerUnmanaged(i), field6.PointerUnmanaged(i), field7.PointerUnmanaged(i), field8.PointerUnmanaged(i), field9.PointerUnmanaged(i), field10.PointerUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSharedUnmanaged(i), field1.PointerSharedUnmanaged(i), field2.PointerSharedUnmanaged(i), field3.PointerSharedUnmanaged(i), field4.PointerSharedUnmanaged(i), field5.PointerSharedUnmanaged(i), field6.PointerSharedUnmanaged(i), field7.PointerSharedUnmanaged(i), field8.PointerSharedUnmanaged(i), field9.PointerSharedUnmanaged(i), field10.PointerSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSparseUnmanaged(i), field1.PointerSparseUnmanaged(i), field2.PointerSparseUnmanaged(i), field3.PointerSparseUnmanaged(i), field4.PointerSparseUnmanaged(i), field5.PointerSparseUnmanaged(i), field6.PointerSparseUnmanaged(i), field7.PointerSparseUnmanaged(i), field8.PointerSparseUnmanaged(i), field9.PointerSparseUnmanaged(i), field10.PointerSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSparseSharedUnmanaged(i), field1.PointerSparseSharedUnmanaged(i), field2.PointerSparseSharedUnmanaged(i), field3.PointerSparseSharedUnmanaged(i), field4.PointerSparseSharedUnmanaged(i), field5.PointerSparseSharedUnmanaged(i), field6.PointerSparseSharedUnmanaged(i), field7.PointerSparseSharedUnmanaged(i), field8.PointerSparseSharedUnmanaged(i), field9.PointerSparseSharedUnmanaged(i), field10.PointerSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerManaged(i), field1.PointerManaged(i), field2.PointerManaged(i), field3.PointerManaged(i), field4.PointerManaged(i), field5.PointerManaged(i), field6.PointerManaged(i), field7.PointerManaged(i), field8.PointerManaged(i), field9.PointerManaged(i), field10.PointerManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSharedManaged(i), field1.PointerSharedManaged(i), field2.PointerSharedManaged(i), field3.PointerSharedManaged(i), field4.PointerSharedManaged(i), field5.PointerSharedManaged(i), field6.PointerSharedManaged(i), field7.PointerSharedManaged(i), field8.PointerSharedManaged(i), field9.PointerSharedManaged(i), field10.PointerSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSparseManaged(i), field1.PointerSparseManaged(i), field2.PointerSparseManaged(i), field3.PointerSparseManaged(i), field4.PointerSparseManaged(i), field5.PointerSparseManaged(i), field6.PointerSparseManaged(i), field7.PointerSparseManaged(i), field8.PointerSparseManaged(i), field9.PointerSparseManaged(i), field10.PointerSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSparseSharedManaged(i), field1.PointerSparseSharedManaged(i), field2.PointerSparseSharedManaged(i), field3.PointerSparseSharedManaged(i), field4.PointerSparseSharedManaged(i), field5.PointerSparseSharedManaged(i), field6.PointerSparseSharedManaged(i), field7.PointerSparseSharedManaged(i), field8.PointerSparseSharedManaged(i), field9.PointerSparseSharedManaged(i), field10.PointerSparseSharedManaged(i));
+        }
     }
 
     /// <summary>
@@ -227,15 +1009,93 @@ public static void Each<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(Iter it, de
     {
         int count = it.Handle->count; Ecs.Assert(it.Handle->count > 0, "No entities returned, use Iter() or Each() without the entity argument instead.");
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8); byte* pointer9 = (byte*)it.GetPointer<T9>(9); byte* pointer10 = (byte*)it.GetPointer<T10>(10);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8); int step9 = it.Step<T9>(9); int step10 = it.Step<T10>(10);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8); FieldData<T9> field9 = it.GetFieldData<T9>(9); FieldData<T10> field10 = it.GetFieldData<T10>(10);
+        IterationTechnique flags = it.GetIterationTechnique(11);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8], pointer9 = &pointer9[step9], pointer10 = &pointer10[step10])
-            callback(new Entity(it.Handle->world, it.Handle->entities[i]), (T0*)pointer0, (T1*)pointer1, (T2*)pointer2, (T3*)pointer3, (T4*)pointer4, (T5*)pointer5, (T6*)pointer6, (T7*)pointer7, (T8*)pointer8, (T9*)pointer9, (T10*)pointer10);
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>() || RuntimeHelpers.IsReferenceOrContainsReferences<T9>() || RuntimeHelpers.IsReferenceOrContainsReferences<T10>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerUnmanaged(i), field1.PointerUnmanaged(i), field2.PointerUnmanaged(i), field3.PointerUnmanaged(i), field4.PointerUnmanaged(i), field5.PointerUnmanaged(i), field6.PointerUnmanaged(i), field7.PointerUnmanaged(i), field8.PointerUnmanaged(i), field9.PointerUnmanaged(i), field10.PointerUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSharedUnmanaged(i), field1.PointerSharedUnmanaged(i), field2.PointerSharedUnmanaged(i), field3.PointerSharedUnmanaged(i), field4.PointerSharedUnmanaged(i), field5.PointerSharedUnmanaged(i), field6.PointerSharedUnmanaged(i), field7.PointerSharedUnmanaged(i), field8.PointerSharedUnmanaged(i), field9.PointerSharedUnmanaged(i), field10.PointerSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseUnmanaged(i), field1.PointerSparseUnmanaged(i), field2.PointerSparseUnmanaged(i), field3.PointerSparseUnmanaged(i), field4.PointerSparseUnmanaged(i), field5.PointerSparseUnmanaged(i), field6.PointerSparseUnmanaged(i), field7.PointerSparseUnmanaged(i), field8.PointerSparseUnmanaged(i), field9.PointerSparseUnmanaged(i), field10.PointerSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseSharedUnmanaged(i), field1.PointerSparseSharedUnmanaged(i), field2.PointerSparseSharedUnmanaged(i), field3.PointerSparseSharedUnmanaged(i), field4.PointerSparseSharedUnmanaged(i), field5.PointerSparseSharedUnmanaged(i), field6.PointerSparseSharedUnmanaged(i), field7.PointerSparseSharedUnmanaged(i), field8.PointerSparseSharedUnmanaged(i), field9.PointerSparseSharedUnmanaged(i), field10.PointerSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerManaged(i), field1.PointerManaged(i), field2.PointerManaged(i), field3.PointerManaged(i), field4.PointerManaged(i), field5.PointerManaged(i), field6.PointerManaged(i), field7.PointerManaged(i), field8.PointerManaged(i), field9.PointerManaged(i), field10.PointerManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSharedManaged(i), field1.PointerSharedManaged(i), field2.PointerSharedManaged(i), field3.PointerSharedManaged(i), field4.PointerSharedManaged(i), field5.PointerSharedManaged(i), field6.PointerSharedManaged(i), field7.PointerSharedManaged(i), field8.PointerSharedManaged(i), field9.PointerSharedManaged(i), field10.PointerSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseManaged(i), field1.PointerSparseManaged(i), field2.PointerSparseManaged(i), field3.PointerSparseManaged(i), field4.PointerSparseManaged(i), field5.PointerSparseManaged(i), field6.PointerSparseManaged(i), field7.PointerSparseManaged(i), field8.PointerSparseManaged(i), field9.PointerSparseManaged(i), field10.PointerSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseSharedManaged(i), field1.PointerSparseSharedManaged(i), field2.PointerSparseSharedManaged(i), field3.PointerSparseSharedManaged(i), field4.PointerSparseSharedManaged(i), field5.PointerSparseSharedManaged(i), field6.PointerSparseSharedManaged(i), field7.PointerSparseSharedManaged(i), field8.PointerSparseSharedManaged(i), field9.PointerSparseSharedManaged(i), field10.PointerSparseSharedManaged(i));
+        }
     }
 
     /// <summary>
@@ -248,14 +1108,92 @@ public static void Each<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(Iter it, de
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8); byte* pointer9 = (byte*)it.GetPointer<T9>(9); byte* pointer10 = (byte*)it.GetPointer<T10>(10);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8); int step9 = it.Step<T9>(9); int step10 = it.Step<T10>(10);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8); FieldData<T9> field9 = it.GetFieldData<T9>(9); FieldData<T10> field10 = it.GetFieldData<T10>(10);
+        IterationTechnique flags = it.GetIterationTechnique(11);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8], pointer9 = &pointer9[step9], pointer10 = &pointer10[step10])
-            callback(it, i, (T0*)pointer0, (T1*)pointer1, (T2*)pointer2, (T3*)pointer3, (T4*)pointer4, (T5*)pointer5, (T6*)pointer6, (T7*)pointer7, (T8*)pointer8, (T9*)pointer9, (T10*)pointer10);
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>() || RuntimeHelpers.IsReferenceOrContainsReferences<T9>() || RuntimeHelpers.IsReferenceOrContainsReferences<T10>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerUnmanaged(i), field1.PointerUnmanaged(i), field2.PointerUnmanaged(i), field3.PointerUnmanaged(i), field4.PointerUnmanaged(i), field5.PointerUnmanaged(i), field6.PointerUnmanaged(i), field7.PointerUnmanaged(i), field8.PointerUnmanaged(i), field9.PointerUnmanaged(i), field10.PointerUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSharedUnmanaged(i), field1.PointerSharedUnmanaged(i), field2.PointerSharedUnmanaged(i), field3.PointerSharedUnmanaged(i), field4.PointerSharedUnmanaged(i), field5.PointerSharedUnmanaged(i), field6.PointerSharedUnmanaged(i), field7.PointerSharedUnmanaged(i), field8.PointerSharedUnmanaged(i), field9.PointerSharedUnmanaged(i), field10.PointerSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSparseUnmanaged(i), field1.PointerSparseUnmanaged(i), field2.PointerSparseUnmanaged(i), field3.PointerSparseUnmanaged(i), field4.PointerSparseUnmanaged(i), field5.PointerSparseUnmanaged(i), field6.PointerSparseUnmanaged(i), field7.PointerSparseUnmanaged(i), field8.PointerSparseUnmanaged(i), field9.PointerSparseUnmanaged(i), field10.PointerSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSparseSharedUnmanaged(i), field1.PointerSparseSharedUnmanaged(i), field2.PointerSparseSharedUnmanaged(i), field3.PointerSparseSharedUnmanaged(i), field4.PointerSparseSharedUnmanaged(i), field5.PointerSparseSharedUnmanaged(i), field6.PointerSparseSharedUnmanaged(i), field7.PointerSparseSharedUnmanaged(i), field8.PointerSparseSharedUnmanaged(i), field9.PointerSparseSharedUnmanaged(i), field10.PointerSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerManaged(i), field1.PointerManaged(i), field2.PointerManaged(i), field3.PointerManaged(i), field4.PointerManaged(i), field5.PointerManaged(i), field6.PointerManaged(i), field7.PointerManaged(i), field8.PointerManaged(i), field9.PointerManaged(i), field10.PointerManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSharedManaged(i), field1.PointerSharedManaged(i), field2.PointerSharedManaged(i), field3.PointerSharedManaged(i), field4.PointerSharedManaged(i), field5.PointerSharedManaged(i), field6.PointerSharedManaged(i), field7.PointerSharedManaged(i), field8.PointerSharedManaged(i), field9.PointerSharedManaged(i), field10.PointerSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSparseManaged(i), field1.PointerSparseManaged(i), field2.PointerSparseManaged(i), field3.PointerSparseManaged(i), field4.PointerSparseManaged(i), field5.PointerSparseManaged(i), field6.PointerSparseManaged(i), field7.PointerSparseManaged(i), field8.PointerSparseManaged(i), field9.PointerSparseManaged(i), field10.PointerSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSparseSharedManaged(i), field1.PointerSparseSharedManaged(i), field2.PointerSparseSharedManaged(i), field3.PointerSparseSharedManaged(i), field4.PointerSparseSharedManaged(i), field5.PointerSparseSharedManaged(i), field6.PointerSparseSharedManaged(i), field7.PointerSparseSharedManaged(i), field8.PointerSparseSharedManaged(i), field9.PointerSparseSharedManaged(i), field10.PointerSparseSharedManaged(i));
+        }
     }
 }
\ No newline at end of file
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/Invoker/Each/Iterator/T12.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/Invoker/Each/Iterator/T12.g.cs
index dd16c30e..5359040a 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/Invoker/Each/Iterator/T12.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/Invoker/Each/Iterator/T12.g.cs
@@ -1,5 +1,7 @@
 // Each/Iterator/T12.g.cs
 // File was auto-generated by /_/src/Flecs.NET.Codegen/Generators/Invoker.cs
+using System;
+using System.Runtime.CompilerServices;
 using Flecs.NET.Utilities;
 using static Flecs.NET.Bindings.flecs;
 
@@ -17,15 +19,93 @@ public static void Each<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(Iter i
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8); byte* pointer9 = (byte*)it.GetPointer<T9>(9); byte* pointer10 = (byte*)it.GetPointer<T10>(10); byte* pointer11 = (byte*)it.GetPointer<T11>(11);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8); int step9 = it.Step<T9>(9); int step10 = it.Step<T10>(10); int step11 = it.Step<T11>(11);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8); FieldData<T9> field9 = it.GetFieldData<T9>(9); FieldData<T10> field10 = it.GetFieldData<T10>(10); FieldData<T11> field11 = it.GetFieldData<T11>(11);
+        IterationTechnique flags = it.GetIterationTechnique(12);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8], pointer9 = &pointer9[step9], pointer10 = &pointer10[step10], pointer11 = &pointer11[step11])
-            callback(ref Managed.GetTypeRef<T0>(pointer0), ref Managed.GetTypeRef<T1>(pointer1), ref Managed.GetTypeRef<T2>(pointer2), ref Managed.GetTypeRef<T3>(pointer3), ref Managed.GetTypeRef<T4>(pointer4), ref Managed.GetTypeRef<T5>(pointer5), ref Managed.GetTypeRef<T6>(pointer6), ref Managed.GetTypeRef<T7>(pointer7), ref Managed.GetTypeRef<T8>(pointer8), ref Managed.GetTypeRef<T9>(pointer9), ref Managed.GetTypeRef<T10>(pointer10), ref Managed.GetTypeRef<T11>(pointer11));
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>() || RuntimeHelpers.IsReferenceOrContainsReferences<T9>() || RuntimeHelpers.IsReferenceOrContainsReferences<T10>() || RuntimeHelpers.IsReferenceOrContainsReferences<T11>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefUnmanaged(i), ref field1.RefUnmanaged(i), ref field2.RefUnmanaged(i), ref field3.RefUnmanaged(i), ref field4.RefUnmanaged(i), ref field5.RefUnmanaged(i), ref field6.RefUnmanaged(i), ref field7.RefUnmanaged(i), ref field8.RefUnmanaged(i), ref field9.RefUnmanaged(i), ref field10.RefUnmanaged(i), ref field11.RefUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSharedUnmanaged(i), ref field1.RefSharedUnmanaged(i), ref field2.RefSharedUnmanaged(i), ref field3.RefSharedUnmanaged(i), ref field4.RefSharedUnmanaged(i), ref field5.RefSharedUnmanaged(i), ref field6.RefSharedUnmanaged(i), ref field7.RefSharedUnmanaged(i), ref field8.RefSharedUnmanaged(i), ref field9.RefSharedUnmanaged(i), ref field10.RefSharedUnmanaged(i), ref field11.RefSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSparseUnmanaged(i), ref field1.RefSparseUnmanaged(i), ref field2.RefSparseUnmanaged(i), ref field3.RefSparseUnmanaged(i), ref field4.RefSparseUnmanaged(i), ref field5.RefSparseUnmanaged(i), ref field6.RefSparseUnmanaged(i), ref field7.RefSparseUnmanaged(i), ref field8.RefSparseUnmanaged(i), ref field9.RefSparseUnmanaged(i), ref field10.RefSparseUnmanaged(i), ref field11.RefSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSparseSharedUnmanaged(i), ref field1.RefSparseSharedUnmanaged(i), ref field2.RefSparseSharedUnmanaged(i), ref field3.RefSparseSharedUnmanaged(i), ref field4.RefSparseSharedUnmanaged(i), ref field5.RefSparseSharedUnmanaged(i), ref field6.RefSparseSharedUnmanaged(i), ref field7.RefSparseSharedUnmanaged(i), ref field8.RefSparseSharedUnmanaged(i), ref field9.RefSparseSharedUnmanaged(i), ref field10.RefSparseSharedUnmanaged(i), ref field11.RefSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefManaged(i), ref field1.RefManaged(i), ref field2.RefManaged(i), ref field3.RefManaged(i), ref field4.RefManaged(i), ref field5.RefManaged(i), ref field6.RefManaged(i), ref field7.RefManaged(i), ref field8.RefManaged(i), ref field9.RefManaged(i), ref field10.RefManaged(i), ref field11.RefManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSharedManaged(i), ref field1.RefSharedManaged(i), ref field2.RefSharedManaged(i), ref field3.RefSharedManaged(i), ref field4.RefSharedManaged(i), ref field5.RefSharedManaged(i), ref field6.RefSharedManaged(i), ref field7.RefSharedManaged(i), ref field8.RefSharedManaged(i), ref field9.RefSharedManaged(i), ref field10.RefSharedManaged(i), ref field11.RefSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSparseManaged(i), ref field1.RefSparseManaged(i), ref field2.RefSparseManaged(i), ref field3.RefSparseManaged(i), ref field4.RefSparseManaged(i), ref field5.RefSparseManaged(i), ref field6.RefSparseManaged(i), ref field7.RefSparseManaged(i), ref field8.RefSparseManaged(i), ref field9.RefSparseManaged(i), ref field10.RefSparseManaged(i), ref field11.RefSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSparseSharedManaged(i), ref field1.RefSparseSharedManaged(i), ref field2.RefSparseSharedManaged(i), ref field3.RefSparseSharedManaged(i), ref field4.RefSparseSharedManaged(i), ref field5.RefSparseSharedManaged(i), ref field6.RefSparseSharedManaged(i), ref field7.RefSparseSharedManaged(i), ref field8.RefSparseSharedManaged(i), ref field9.RefSparseSharedManaged(i), ref field10.RefSparseSharedManaged(i), ref field11.RefSparseSharedManaged(i));
+        }
     }
 
     /// <summary>
@@ -38,15 +118,93 @@ public static void Each<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(Iter i
     {
         int count = it.Handle->count; Ecs.Assert(it.Handle->count > 0, "No entities returned, use Iter() or Each() without the entity argument instead.");
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8); byte* pointer9 = (byte*)it.GetPointer<T9>(9); byte* pointer10 = (byte*)it.GetPointer<T10>(10); byte* pointer11 = (byte*)it.GetPointer<T11>(11);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8); int step9 = it.Step<T9>(9); int step10 = it.Step<T10>(10); int step11 = it.Step<T11>(11);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8); FieldData<T9> field9 = it.GetFieldData<T9>(9); FieldData<T10> field10 = it.GetFieldData<T10>(10); FieldData<T11> field11 = it.GetFieldData<T11>(11);
+        IterationTechnique flags = it.GetIterationTechnique(12);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8], pointer9 = &pointer9[step9], pointer10 = &pointer10[step10], pointer11 = &pointer11[step11])
-            callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref Managed.GetTypeRef<T0>(pointer0), ref Managed.GetTypeRef<T1>(pointer1), ref Managed.GetTypeRef<T2>(pointer2), ref Managed.GetTypeRef<T3>(pointer3), ref Managed.GetTypeRef<T4>(pointer4), ref Managed.GetTypeRef<T5>(pointer5), ref Managed.GetTypeRef<T6>(pointer6), ref Managed.GetTypeRef<T7>(pointer7), ref Managed.GetTypeRef<T8>(pointer8), ref Managed.GetTypeRef<T9>(pointer9), ref Managed.GetTypeRef<T10>(pointer10), ref Managed.GetTypeRef<T11>(pointer11));
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>() || RuntimeHelpers.IsReferenceOrContainsReferences<T9>() || RuntimeHelpers.IsReferenceOrContainsReferences<T10>() || RuntimeHelpers.IsReferenceOrContainsReferences<T11>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefUnmanaged(i), ref field1.RefUnmanaged(i), ref field2.RefUnmanaged(i), ref field3.RefUnmanaged(i), ref field4.RefUnmanaged(i), ref field5.RefUnmanaged(i), ref field6.RefUnmanaged(i), ref field7.RefUnmanaged(i), ref field8.RefUnmanaged(i), ref field9.RefUnmanaged(i), ref field10.RefUnmanaged(i), ref field11.RefUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSharedUnmanaged(i), ref field1.RefSharedUnmanaged(i), ref field2.RefSharedUnmanaged(i), ref field3.RefSharedUnmanaged(i), ref field4.RefSharedUnmanaged(i), ref field5.RefSharedUnmanaged(i), ref field6.RefSharedUnmanaged(i), ref field7.RefSharedUnmanaged(i), ref field8.RefSharedUnmanaged(i), ref field9.RefSharedUnmanaged(i), ref field10.RefSharedUnmanaged(i), ref field11.RefSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseUnmanaged(i), ref field1.RefSparseUnmanaged(i), ref field2.RefSparseUnmanaged(i), ref field3.RefSparseUnmanaged(i), ref field4.RefSparseUnmanaged(i), ref field5.RefSparseUnmanaged(i), ref field6.RefSparseUnmanaged(i), ref field7.RefSparseUnmanaged(i), ref field8.RefSparseUnmanaged(i), ref field9.RefSparseUnmanaged(i), ref field10.RefSparseUnmanaged(i), ref field11.RefSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseSharedUnmanaged(i), ref field1.RefSparseSharedUnmanaged(i), ref field2.RefSparseSharedUnmanaged(i), ref field3.RefSparseSharedUnmanaged(i), ref field4.RefSparseSharedUnmanaged(i), ref field5.RefSparseSharedUnmanaged(i), ref field6.RefSparseSharedUnmanaged(i), ref field7.RefSparseSharedUnmanaged(i), ref field8.RefSparseSharedUnmanaged(i), ref field9.RefSparseSharedUnmanaged(i), ref field10.RefSparseSharedUnmanaged(i), ref field11.RefSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefManaged(i), ref field1.RefManaged(i), ref field2.RefManaged(i), ref field3.RefManaged(i), ref field4.RefManaged(i), ref field5.RefManaged(i), ref field6.RefManaged(i), ref field7.RefManaged(i), ref field8.RefManaged(i), ref field9.RefManaged(i), ref field10.RefManaged(i), ref field11.RefManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSharedManaged(i), ref field1.RefSharedManaged(i), ref field2.RefSharedManaged(i), ref field3.RefSharedManaged(i), ref field4.RefSharedManaged(i), ref field5.RefSharedManaged(i), ref field6.RefSharedManaged(i), ref field7.RefSharedManaged(i), ref field8.RefSharedManaged(i), ref field9.RefSharedManaged(i), ref field10.RefSharedManaged(i), ref field11.RefSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseManaged(i), ref field1.RefSparseManaged(i), ref field2.RefSparseManaged(i), ref field3.RefSparseManaged(i), ref field4.RefSparseManaged(i), ref field5.RefSparseManaged(i), ref field6.RefSparseManaged(i), ref field7.RefSparseManaged(i), ref field8.RefSparseManaged(i), ref field9.RefSparseManaged(i), ref field10.RefSparseManaged(i), ref field11.RefSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseSharedManaged(i), ref field1.RefSparseSharedManaged(i), ref field2.RefSparseSharedManaged(i), ref field3.RefSparseSharedManaged(i), ref field4.RefSparseSharedManaged(i), ref field5.RefSparseSharedManaged(i), ref field6.RefSparseSharedManaged(i), ref field7.RefSparseSharedManaged(i), ref field8.RefSparseSharedManaged(i), ref field9.RefSparseSharedManaged(i), ref field10.RefSparseSharedManaged(i), ref field11.RefSparseSharedManaged(i));
+        }
     }
 
     /// <summary>
@@ -59,15 +217,93 @@ public static void Each<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(Iter i
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8); byte* pointer9 = (byte*)it.GetPointer<T9>(9); byte* pointer10 = (byte*)it.GetPointer<T10>(10); byte* pointer11 = (byte*)it.GetPointer<T11>(11);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8); int step9 = it.Step<T9>(9); int step10 = it.Step<T10>(10); int step11 = it.Step<T11>(11);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8); FieldData<T9> field9 = it.GetFieldData<T9>(9); FieldData<T10> field10 = it.GetFieldData<T10>(10); FieldData<T11> field11 = it.GetFieldData<T11>(11);
+        IterationTechnique flags = it.GetIterationTechnique(12);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8], pointer9 = &pointer9[step9], pointer10 = &pointer10[step10], pointer11 = &pointer11[step11])
-            callback(it, i, ref Managed.GetTypeRef<T0>(pointer0), ref Managed.GetTypeRef<T1>(pointer1), ref Managed.GetTypeRef<T2>(pointer2), ref Managed.GetTypeRef<T3>(pointer3), ref Managed.GetTypeRef<T4>(pointer4), ref Managed.GetTypeRef<T5>(pointer5), ref Managed.GetTypeRef<T6>(pointer6), ref Managed.GetTypeRef<T7>(pointer7), ref Managed.GetTypeRef<T8>(pointer8), ref Managed.GetTypeRef<T9>(pointer9), ref Managed.GetTypeRef<T10>(pointer10), ref Managed.GetTypeRef<T11>(pointer11));
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>() || RuntimeHelpers.IsReferenceOrContainsReferences<T9>() || RuntimeHelpers.IsReferenceOrContainsReferences<T10>() || RuntimeHelpers.IsReferenceOrContainsReferences<T11>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefUnmanaged(i), ref field1.RefUnmanaged(i), ref field2.RefUnmanaged(i), ref field3.RefUnmanaged(i), ref field4.RefUnmanaged(i), ref field5.RefUnmanaged(i), ref field6.RefUnmanaged(i), ref field7.RefUnmanaged(i), ref field8.RefUnmanaged(i), ref field9.RefUnmanaged(i), ref field10.RefUnmanaged(i), ref field11.RefUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSharedUnmanaged(i), ref field1.RefSharedUnmanaged(i), ref field2.RefSharedUnmanaged(i), ref field3.RefSharedUnmanaged(i), ref field4.RefSharedUnmanaged(i), ref field5.RefSharedUnmanaged(i), ref field6.RefSharedUnmanaged(i), ref field7.RefSharedUnmanaged(i), ref field8.RefSharedUnmanaged(i), ref field9.RefSharedUnmanaged(i), ref field10.RefSharedUnmanaged(i), ref field11.RefSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSparseUnmanaged(i), ref field1.RefSparseUnmanaged(i), ref field2.RefSparseUnmanaged(i), ref field3.RefSparseUnmanaged(i), ref field4.RefSparseUnmanaged(i), ref field5.RefSparseUnmanaged(i), ref field6.RefSparseUnmanaged(i), ref field7.RefSparseUnmanaged(i), ref field8.RefSparseUnmanaged(i), ref field9.RefSparseUnmanaged(i), ref field10.RefSparseUnmanaged(i), ref field11.RefSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSparseSharedUnmanaged(i), ref field1.RefSparseSharedUnmanaged(i), ref field2.RefSparseSharedUnmanaged(i), ref field3.RefSparseSharedUnmanaged(i), ref field4.RefSparseSharedUnmanaged(i), ref field5.RefSparseSharedUnmanaged(i), ref field6.RefSparseSharedUnmanaged(i), ref field7.RefSparseSharedUnmanaged(i), ref field8.RefSparseSharedUnmanaged(i), ref field9.RefSparseSharedUnmanaged(i), ref field10.RefSparseSharedUnmanaged(i), ref field11.RefSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefManaged(i), ref field1.RefManaged(i), ref field2.RefManaged(i), ref field3.RefManaged(i), ref field4.RefManaged(i), ref field5.RefManaged(i), ref field6.RefManaged(i), ref field7.RefManaged(i), ref field8.RefManaged(i), ref field9.RefManaged(i), ref field10.RefManaged(i), ref field11.RefManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSharedManaged(i), ref field1.RefSharedManaged(i), ref field2.RefSharedManaged(i), ref field3.RefSharedManaged(i), ref field4.RefSharedManaged(i), ref field5.RefSharedManaged(i), ref field6.RefSharedManaged(i), ref field7.RefSharedManaged(i), ref field8.RefSharedManaged(i), ref field9.RefSharedManaged(i), ref field10.RefSharedManaged(i), ref field11.RefSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSparseManaged(i), ref field1.RefSparseManaged(i), ref field2.RefSparseManaged(i), ref field3.RefSparseManaged(i), ref field4.RefSparseManaged(i), ref field5.RefSparseManaged(i), ref field6.RefSparseManaged(i), ref field7.RefSparseManaged(i), ref field8.RefSparseManaged(i), ref field9.RefSparseManaged(i), ref field10.RefSparseManaged(i), ref field11.RefSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSparseSharedManaged(i), ref field1.RefSparseSharedManaged(i), ref field2.RefSparseSharedManaged(i), ref field3.RefSparseSharedManaged(i), ref field4.RefSparseSharedManaged(i), ref field5.RefSparseSharedManaged(i), ref field6.RefSparseSharedManaged(i), ref field7.RefSparseSharedManaged(i), ref field8.RefSparseSharedManaged(i), ref field9.RefSparseSharedManaged(i), ref field10.RefSparseSharedManaged(i), ref field11.RefSparseSharedManaged(i));
+        }
     }
 
     /// <summary>
@@ -80,15 +316,93 @@ public static void Each<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(Iter i
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8); byte* pointer9 = (byte*)it.GetPointer<T9>(9); byte* pointer10 = (byte*)it.GetPointer<T10>(10); byte* pointer11 = (byte*)it.GetPointer<T11>(11);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8); int step9 = it.Step<T9>(9); int step10 = it.Step<T10>(10); int step11 = it.Step<T11>(11);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8); FieldData<T9> field9 = it.GetFieldData<T9>(9); FieldData<T10> field10 = it.GetFieldData<T10>(10); FieldData<T11> field11 = it.GetFieldData<T11>(11);
+        IterationTechnique flags = it.GetIterationTechnique(12);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8], pointer9 = &pointer9[step9], pointer10 = &pointer10[step10], pointer11 = &pointer11[step11])
-            callback(ref Managed.GetTypeRef<T0>(pointer0), ref Managed.GetTypeRef<T1>(pointer1), ref Managed.GetTypeRef<T2>(pointer2), ref Managed.GetTypeRef<T3>(pointer3), ref Managed.GetTypeRef<T4>(pointer4), ref Managed.GetTypeRef<T5>(pointer5), ref Managed.GetTypeRef<T6>(pointer6), ref Managed.GetTypeRef<T7>(pointer7), ref Managed.GetTypeRef<T8>(pointer8), ref Managed.GetTypeRef<T9>(pointer9), ref Managed.GetTypeRef<T10>(pointer10), ref Managed.GetTypeRef<T11>(pointer11));
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>() || RuntimeHelpers.IsReferenceOrContainsReferences<T9>() || RuntimeHelpers.IsReferenceOrContainsReferences<T10>() || RuntimeHelpers.IsReferenceOrContainsReferences<T11>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefUnmanaged(i), ref field1.RefUnmanaged(i), ref field2.RefUnmanaged(i), ref field3.RefUnmanaged(i), ref field4.RefUnmanaged(i), ref field5.RefUnmanaged(i), ref field6.RefUnmanaged(i), ref field7.RefUnmanaged(i), ref field8.RefUnmanaged(i), ref field9.RefUnmanaged(i), ref field10.RefUnmanaged(i), ref field11.RefUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSharedUnmanaged(i), ref field1.RefSharedUnmanaged(i), ref field2.RefSharedUnmanaged(i), ref field3.RefSharedUnmanaged(i), ref field4.RefSharedUnmanaged(i), ref field5.RefSharedUnmanaged(i), ref field6.RefSharedUnmanaged(i), ref field7.RefSharedUnmanaged(i), ref field8.RefSharedUnmanaged(i), ref field9.RefSharedUnmanaged(i), ref field10.RefSharedUnmanaged(i), ref field11.RefSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSparseUnmanaged(i), ref field1.RefSparseUnmanaged(i), ref field2.RefSparseUnmanaged(i), ref field3.RefSparseUnmanaged(i), ref field4.RefSparseUnmanaged(i), ref field5.RefSparseUnmanaged(i), ref field6.RefSparseUnmanaged(i), ref field7.RefSparseUnmanaged(i), ref field8.RefSparseUnmanaged(i), ref field9.RefSparseUnmanaged(i), ref field10.RefSparseUnmanaged(i), ref field11.RefSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSparseSharedUnmanaged(i), ref field1.RefSparseSharedUnmanaged(i), ref field2.RefSparseSharedUnmanaged(i), ref field3.RefSparseSharedUnmanaged(i), ref field4.RefSparseSharedUnmanaged(i), ref field5.RefSparseSharedUnmanaged(i), ref field6.RefSparseSharedUnmanaged(i), ref field7.RefSparseSharedUnmanaged(i), ref field8.RefSparseSharedUnmanaged(i), ref field9.RefSparseSharedUnmanaged(i), ref field10.RefSparseSharedUnmanaged(i), ref field11.RefSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefManaged(i), ref field1.RefManaged(i), ref field2.RefManaged(i), ref field3.RefManaged(i), ref field4.RefManaged(i), ref field5.RefManaged(i), ref field6.RefManaged(i), ref field7.RefManaged(i), ref field8.RefManaged(i), ref field9.RefManaged(i), ref field10.RefManaged(i), ref field11.RefManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSharedManaged(i), ref field1.RefSharedManaged(i), ref field2.RefSharedManaged(i), ref field3.RefSharedManaged(i), ref field4.RefSharedManaged(i), ref field5.RefSharedManaged(i), ref field6.RefSharedManaged(i), ref field7.RefSharedManaged(i), ref field8.RefSharedManaged(i), ref field9.RefSharedManaged(i), ref field10.RefSharedManaged(i), ref field11.RefSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSparseManaged(i), ref field1.RefSparseManaged(i), ref field2.RefSparseManaged(i), ref field3.RefSparseManaged(i), ref field4.RefSparseManaged(i), ref field5.RefSparseManaged(i), ref field6.RefSparseManaged(i), ref field7.RefSparseManaged(i), ref field8.RefSparseManaged(i), ref field9.RefSparseManaged(i), ref field10.RefSparseManaged(i), ref field11.RefSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSparseSharedManaged(i), ref field1.RefSparseSharedManaged(i), ref field2.RefSparseSharedManaged(i), ref field3.RefSparseSharedManaged(i), ref field4.RefSparseSharedManaged(i), ref field5.RefSparseSharedManaged(i), ref field6.RefSparseSharedManaged(i), ref field7.RefSparseSharedManaged(i), ref field8.RefSparseSharedManaged(i), ref field9.RefSparseSharedManaged(i), ref field10.RefSparseSharedManaged(i), ref field11.RefSparseSharedManaged(i));
+        }
     }
 
     /// <summary>
@@ -101,15 +415,93 @@ public static void Each<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(Iter i
     {
         int count = it.Handle->count; Ecs.Assert(it.Handle->count > 0, "No entities returned, use Iter() or Each() without the entity argument instead.");
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8); byte* pointer9 = (byte*)it.GetPointer<T9>(9); byte* pointer10 = (byte*)it.GetPointer<T10>(10); byte* pointer11 = (byte*)it.GetPointer<T11>(11);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8); int step9 = it.Step<T9>(9); int step10 = it.Step<T10>(10); int step11 = it.Step<T11>(11);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8); FieldData<T9> field9 = it.GetFieldData<T9>(9); FieldData<T10> field10 = it.GetFieldData<T10>(10); FieldData<T11> field11 = it.GetFieldData<T11>(11);
+        IterationTechnique flags = it.GetIterationTechnique(12);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8], pointer9 = &pointer9[step9], pointer10 = &pointer10[step10], pointer11 = &pointer11[step11])
-            callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref Managed.GetTypeRef<T0>(pointer0), ref Managed.GetTypeRef<T1>(pointer1), ref Managed.GetTypeRef<T2>(pointer2), ref Managed.GetTypeRef<T3>(pointer3), ref Managed.GetTypeRef<T4>(pointer4), ref Managed.GetTypeRef<T5>(pointer5), ref Managed.GetTypeRef<T6>(pointer6), ref Managed.GetTypeRef<T7>(pointer7), ref Managed.GetTypeRef<T8>(pointer8), ref Managed.GetTypeRef<T9>(pointer9), ref Managed.GetTypeRef<T10>(pointer10), ref Managed.GetTypeRef<T11>(pointer11));
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>() || RuntimeHelpers.IsReferenceOrContainsReferences<T9>() || RuntimeHelpers.IsReferenceOrContainsReferences<T10>() || RuntimeHelpers.IsReferenceOrContainsReferences<T11>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefUnmanaged(i), ref field1.RefUnmanaged(i), ref field2.RefUnmanaged(i), ref field3.RefUnmanaged(i), ref field4.RefUnmanaged(i), ref field5.RefUnmanaged(i), ref field6.RefUnmanaged(i), ref field7.RefUnmanaged(i), ref field8.RefUnmanaged(i), ref field9.RefUnmanaged(i), ref field10.RefUnmanaged(i), ref field11.RefUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSharedUnmanaged(i), ref field1.RefSharedUnmanaged(i), ref field2.RefSharedUnmanaged(i), ref field3.RefSharedUnmanaged(i), ref field4.RefSharedUnmanaged(i), ref field5.RefSharedUnmanaged(i), ref field6.RefSharedUnmanaged(i), ref field7.RefSharedUnmanaged(i), ref field8.RefSharedUnmanaged(i), ref field9.RefSharedUnmanaged(i), ref field10.RefSharedUnmanaged(i), ref field11.RefSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseUnmanaged(i), ref field1.RefSparseUnmanaged(i), ref field2.RefSparseUnmanaged(i), ref field3.RefSparseUnmanaged(i), ref field4.RefSparseUnmanaged(i), ref field5.RefSparseUnmanaged(i), ref field6.RefSparseUnmanaged(i), ref field7.RefSparseUnmanaged(i), ref field8.RefSparseUnmanaged(i), ref field9.RefSparseUnmanaged(i), ref field10.RefSparseUnmanaged(i), ref field11.RefSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseSharedUnmanaged(i), ref field1.RefSparseSharedUnmanaged(i), ref field2.RefSparseSharedUnmanaged(i), ref field3.RefSparseSharedUnmanaged(i), ref field4.RefSparseSharedUnmanaged(i), ref field5.RefSparseSharedUnmanaged(i), ref field6.RefSparseSharedUnmanaged(i), ref field7.RefSparseSharedUnmanaged(i), ref field8.RefSparseSharedUnmanaged(i), ref field9.RefSparseSharedUnmanaged(i), ref field10.RefSparseSharedUnmanaged(i), ref field11.RefSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefManaged(i), ref field1.RefManaged(i), ref field2.RefManaged(i), ref field3.RefManaged(i), ref field4.RefManaged(i), ref field5.RefManaged(i), ref field6.RefManaged(i), ref field7.RefManaged(i), ref field8.RefManaged(i), ref field9.RefManaged(i), ref field10.RefManaged(i), ref field11.RefManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSharedManaged(i), ref field1.RefSharedManaged(i), ref field2.RefSharedManaged(i), ref field3.RefSharedManaged(i), ref field4.RefSharedManaged(i), ref field5.RefSharedManaged(i), ref field6.RefSharedManaged(i), ref field7.RefSharedManaged(i), ref field8.RefSharedManaged(i), ref field9.RefSharedManaged(i), ref field10.RefSharedManaged(i), ref field11.RefSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseManaged(i), ref field1.RefSparseManaged(i), ref field2.RefSparseManaged(i), ref field3.RefSparseManaged(i), ref field4.RefSparseManaged(i), ref field5.RefSparseManaged(i), ref field6.RefSparseManaged(i), ref field7.RefSparseManaged(i), ref field8.RefSparseManaged(i), ref field9.RefSparseManaged(i), ref field10.RefSparseManaged(i), ref field11.RefSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseSharedManaged(i), ref field1.RefSparseSharedManaged(i), ref field2.RefSparseSharedManaged(i), ref field3.RefSparseSharedManaged(i), ref field4.RefSparseSharedManaged(i), ref field5.RefSparseSharedManaged(i), ref field6.RefSparseSharedManaged(i), ref field7.RefSparseSharedManaged(i), ref field8.RefSparseSharedManaged(i), ref field9.RefSparseSharedManaged(i), ref field10.RefSparseSharedManaged(i), ref field11.RefSparseSharedManaged(i));
+        }
     }
 
     /// <summary>
@@ -122,15 +514,93 @@ public static void Each<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(Iter i
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8); byte* pointer9 = (byte*)it.GetPointer<T9>(9); byte* pointer10 = (byte*)it.GetPointer<T10>(10); byte* pointer11 = (byte*)it.GetPointer<T11>(11);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8); int step9 = it.Step<T9>(9); int step10 = it.Step<T10>(10); int step11 = it.Step<T11>(11);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8); FieldData<T9> field9 = it.GetFieldData<T9>(9); FieldData<T10> field10 = it.GetFieldData<T10>(10); FieldData<T11> field11 = it.GetFieldData<T11>(11);
+        IterationTechnique flags = it.GetIterationTechnique(12);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8], pointer9 = &pointer9[step9], pointer10 = &pointer10[step10], pointer11 = &pointer11[step11])
-            callback(it, i, ref Managed.GetTypeRef<T0>(pointer0), ref Managed.GetTypeRef<T1>(pointer1), ref Managed.GetTypeRef<T2>(pointer2), ref Managed.GetTypeRef<T3>(pointer3), ref Managed.GetTypeRef<T4>(pointer4), ref Managed.GetTypeRef<T5>(pointer5), ref Managed.GetTypeRef<T6>(pointer6), ref Managed.GetTypeRef<T7>(pointer7), ref Managed.GetTypeRef<T8>(pointer8), ref Managed.GetTypeRef<T9>(pointer9), ref Managed.GetTypeRef<T10>(pointer10), ref Managed.GetTypeRef<T11>(pointer11));
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>() || RuntimeHelpers.IsReferenceOrContainsReferences<T9>() || RuntimeHelpers.IsReferenceOrContainsReferences<T10>() || RuntimeHelpers.IsReferenceOrContainsReferences<T11>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefUnmanaged(i), ref field1.RefUnmanaged(i), ref field2.RefUnmanaged(i), ref field3.RefUnmanaged(i), ref field4.RefUnmanaged(i), ref field5.RefUnmanaged(i), ref field6.RefUnmanaged(i), ref field7.RefUnmanaged(i), ref field8.RefUnmanaged(i), ref field9.RefUnmanaged(i), ref field10.RefUnmanaged(i), ref field11.RefUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSharedUnmanaged(i), ref field1.RefSharedUnmanaged(i), ref field2.RefSharedUnmanaged(i), ref field3.RefSharedUnmanaged(i), ref field4.RefSharedUnmanaged(i), ref field5.RefSharedUnmanaged(i), ref field6.RefSharedUnmanaged(i), ref field7.RefSharedUnmanaged(i), ref field8.RefSharedUnmanaged(i), ref field9.RefSharedUnmanaged(i), ref field10.RefSharedUnmanaged(i), ref field11.RefSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSparseUnmanaged(i), ref field1.RefSparseUnmanaged(i), ref field2.RefSparseUnmanaged(i), ref field3.RefSparseUnmanaged(i), ref field4.RefSparseUnmanaged(i), ref field5.RefSparseUnmanaged(i), ref field6.RefSparseUnmanaged(i), ref field7.RefSparseUnmanaged(i), ref field8.RefSparseUnmanaged(i), ref field9.RefSparseUnmanaged(i), ref field10.RefSparseUnmanaged(i), ref field11.RefSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSparseSharedUnmanaged(i), ref field1.RefSparseSharedUnmanaged(i), ref field2.RefSparseSharedUnmanaged(i), ref field3.RefSparseSharedUnmanaged(i), ref field4.RefSparseSharedUnmanaged(i), ref field5.RefSparseSharedUnmanaged(i), ref field6.RefSparseSharedUnmanaged(i), ref field7.RefSparseSharedUnmanaged(i), ref field8.RefSparseSharedUnmanaged(i), ref field9.RefSparseSharedUnmanaged(i), ref field10.RefSparseSharedUnmanaged(i), ref field11.RefSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefManaged(i), ref field1.RefManaged(i), ref field2.RefManaged(i), ref field3.RefManaged(i), ref field4.RefManaged(i), ref field5.RefManaged(i), ref field6.RefManaged(i), ref field7.RefManaged(i), ref field8.RefManaged(i), ref field9.RefManaged(i), ref field10.RefManaged(i), ref field11.RefManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSharedManaged(i), ref field1.RefSharedManaged(i), ref field2.RefSharedManaged(i), ref field3.RefSharedManaged(i), ref field4.RefSharedManaged(i), ref field5.RefSharedManaged(i), ref field6.RefSharedManaged(i), ref field7.RefSharedManaged(i), ref field8.RefSharedManaged(i), ref field9.RefSharedManaged(i), ref field10.RefSharedManaged(i), ref field11.RefSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSparseManaged(i), ref field1.RefSparseManaged(i), ref field2.RefSparseManaged(i), ref field3.RefSparseManaged(i), ref field4.RefSparseManaged(i), ref field5.RefSparseManaged(i), ref field6.RefSparseManaged(i), ref field7.RefSparseManaged(i), ref field8.RefSparseManaged(i), ref field9.RefSparseManaged(i), ref field10.RefSparseManaged(i), ref field11.RefSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSparseSharedManaged(i), ref field1.RefSparseSharedManaged(i), ref field2.RefSparseSharedManaged(i), ref field3.RefSparseSharedManaged(i), ref field4.RefSparseSharedManaged(i), ref field5.RefSparseSharedManaged(i), ref field6.RefSparseSharedManaged(i), ref field7.RefSparseSharedManaged(i), ref field8.RefSparseSharedManaged(i), ref field9.RefSparseSharedManaged(i), ref field10.RefSparseSharedManaged(i), ref field11.RefSparseSharedManaged(i));
+        }
     }
 
     /// <summary>
@@ -143,15 +613,93 @@ public static void Each<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(Iter i
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8); byte* pointer9 = (byte*)it.GetPointer<T9>(9); byte* pointer10 = (byte*)it.GetPointer<T10>(10); byte* pointer11 = (byte*)it.GetPointer<T11>(11);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8); int step9 = it.Step<T9>(9); int step10 = it.Step<T10>(10); int step11 = it.Step<T11>(11);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8); FieldData<T9> field9 = it.GetFieldData<T9>(9); FieldData<T10> field10 = it.GetFieldData<T10>(10); FieldData<T11> field11 = it.GetFieldData<T11>(11);
+        IterationTechnique flags = it.GetIterationTechnique(12);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8], pointer9 = &pointer9[step9], pointer10 = &pointer10[step10], pointer11 = &pointer11[step11])
-            callback((T0*)pointer0, (T1*)pointer1, (T2*)pointer2, (T3*)pointer3, (T4*)pointer4, (T5*)pointer5, (T6*)pointer6, (T7*)pointer7, (T8*)pointer8, (T9*)pointer9, (T10*)pointer10, (T11*)pointer11);
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>() || RuntimeHelpers.IsReferenceOrContainsReferences<T9>() || RuntimeHelpers.IsReferenceOrContainsReferences<T10>() || RuntimeHelpers.IsReferenceOrContainsReferences<T11>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerUnmanaged(i), field1.PointerUnmanaged(i), field2.PointerUnmanaged(i), field3.PointerUnmanaged(i), field4.PointerUnmanaged(i), field5.PointerUnmanaged(i), field6.PointerUnmanaged(i), field7.PointerUnmanaged(i), field8.PointerUnmanaged(i), field9.PointerUnmanaged(i), field10.PointerUnmanaged(i), field11.PointerUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSharedUnmanaged(i), field1.PointerSharedUnmanaged(i), field2.PointerSharedUnmanaged(i), field3.PointerSharedUnmanaged(i), field4.PointerSharedUnmanaged(i), field5.PointerSharedUnmanaged(i), field6.PointerSharedUnmanaged(i), field7.PointerSharedUnmanaged(i), field8.PointerSharedUnmanaged(i), field9.PointerSharedUnmanaged(i), field10.PointerSharedUnmanaged(i), field11.PointerSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSparseUnmanaged(i), field1.PointerSparseUnmanaged(i), field2.PointerSparseUnmanaged(i), field3.PointerSparseUnmanaged(i), field4.PointerSparseUnmanaged(i), field5.PointerSparseUnmanaged(i), field6.PointerSparseUnmanaged(i), field7.PointerSparseUnmanaged(i), field8.PointerSparseUnmanaged(i), field9.PointerSparseUnmanaged(i), field10.PointerSparseUnmanaged(i), field11.PointerSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSparseSharedUnmanaged(i), field1.PointerSparseSharedUnmanaged(i), field2.PointerSparseSharedUnmanaged(i), field3.PointerSparseSharedUnmanaged(i), field4.PointerSparseSharedUnmanaged(i), field5.PointerSparseSharedUnmanaged(i), field6.PointerSparseSharedUnmanaged(i), field7.PointerSparseSharedUnmanaged(i), field8.PointerSparseSharedUnmanaged(i), field9.PointerSparseSharedUnmanaged(i), field10.PointerSparseSharedUnmanaged(i), field11.PointerSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerManaged(i), field1.PointerManaged(i), field2.PointerManaged(i), field3.PointerManaged(i), field4.PointerManaged(i), field5.PointerManaged(i), field6.PointerManaged(i), field7.PointerManaged(i), field8.PointerManaged(i), field9.PointerManaged(i), field10.PointerManaged(i), field11.PointerManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSharedManaged(i), field1.PointerSharedManaged(i), field2.PointerSharedManaged(i), field3.PointerSharedManaged(i), field4.PointerSharedManaged(i), field5.PointerSharedManaged(i), field6.PointerSharedManaged(i), field7.PointerSharedManaged(i), field8.PointerSharedManaged(i), field9.PointerSharedManaged(i), field10.PointerSharedManaged(i), field11.PointerSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSparseManaged(i), field1.PointerSparseManaged(i), field2.PointerSparseManaged(i), field3.PointerSparseManaged(i), field4.PointerSparseManaged(i), field5.PointerSparseManaged(i), field6.PointerSparseManaged(i), field7.PointerSparseManaged(i), field8.PointerSparseManaged(i), field9.PointerSparseManaged(i), field10.PointerSparseManaged(i), field11.PointerSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSparseSharedManaged(i), field1.PointerSparseSharedManaged(i), field2.PointerSparseSharedManaged(i), field3.PointerSparseSharedManaged(i), field4.PointerSparseSharedManaged(i), field5.PointerSparseSharedManaged(i), field6.PointerSparseSharedManaged(i), field7.PointerSparseSharedManaged(i), field8.PointerSparseSharedManaged(i), field9.PointerSparseSharedManaged(i), field10.PointerSparseSharedManaged(i), field11.PointerSparseSharedManaged(i));
+        }
     }
 
     /// <summary>
@@ -164,15 +712,93 @@ public static void Each<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(Iter i
     {
         int count = it.Handle->count; Ecs.Assert(it.Handle->count > 0, "No entities returned, use Iter() or Each() without the entity argument instead.");
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8); byte* pointer9 = (byte*)it.GetPointer<T9>(9); byte* pointer10 = (byte*)it.GetPointer<T10>(10); byte* pointer11 = (byte*)it.GetPointer<T11>(11);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8); int step9 = it.Step<T9>(9); int step10 = it.Step<T10>(10); int step11 = it.Step<T11>(11);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8); FieldData<T9> field9 = it.GetFieldData<T9>(9); FieldData<T10> field10 = it.GetFieldData<T10>(10); FieldData<T11> field11 = it.GetFieldData<T11>(11);
+        IterationTechnique flags = it.GetIterationTechnique(12);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8], pointer9 = &pointer9[step9], pointer10 = &pointer10[step10], pointer11 = &pointer11[step11])
-            callback(new Entity(it.Handle->world, it.Handle->entities[i]), (T0*)pointer0, (T1*)pointer1, (T2*)pointer2, (T3*)pointer3, (T4*)pointer4, (T5*)pointer5, (T6*)pointer6, (T7*)pointer7, (T8*)pointer8, (T9*)pointer9, (T10*)pointer10, (T11*)pointer11);
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>() || RuntimeHelpers.IsReferenceOrContainsReferences<T9>() || RuntimeHelpers.IsReferenceOrContainsReferences<T10>() || RuntimeHelpers.IsReferenceOrContainsReferences<T11>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerUnmanaged(i), field1.PointerUnmanaged(i), field2.PointerUnmanaged(i), field3.PointerUnmanaged(i), field4.PointerUnmanaged(i), field5.PointerUnmanaged(i), field6.PointerUnmanaged(i), field7.PointerUnmanaged(i), field8.PointerUnmanaged(i), field9.PointerUnmanaged(i), field10.PointerUnmanaged(i), field11.PointerUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSharedUnmanaged(i), field1.PointerSharedUnmanaged(i), field2.PointerSharedUnmanaged(i), field3.PointerSharedUnmanaged(i), field4.PointerSharedUnmanaged(i), field5.PointerSharedUnmanaged(i), field6.PointerSharedUnmanaged(i), field7.PointerSharedUnmanaged(i), field8.PointerSharedUnmanaged(i), field9.PointerSharedUnmanaged(i), field10.PointerSharedUnmanaged(i), field11.PointerSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseUnmanaged(i), field1.PointerSparseUnmanaged(i), field2.PointerSparseUnmanaged(i), field3.PointerSparseUnmanaged(i), field4.PointerSparseUnmanaged(i), field5.PointerSparseUnmanaged(i), field6.PointerSparseUnmanaged(i), field7.PointerSparseUnmanaged(i), field8.PointerSparseUnmanaged(i), field9.PointerSparseUnmanaged(i), field10.PointerSparseUnmanaged(i), field11.PointerSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseSharedUnmanaged(i), field1.PointerSparseSharedUnmanaged(i), field2.PointerSparseSharedUnmanaged(i), field3.PointerSparseSharedUnmanaged(i), field4.PointerSparseSharedUnmanaged(i), field5.PointerSparseSharedUnmanaged(i), field6.PointerSparseSharedUnmanaged(i), field7.PointerSparseSharedUnmanaged(i), field8.PointerSparseSharedUnmanaged(i), field9.PointerSparseSharedUnmanaged(i), field10.PointerSparseSharedUnmanaged(i), field11.PointerSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerManaged(i), field1.PointerManaged(i), field2.PointerManaged(i), field3.PointerManaged(i), field4.PointerManaged(i), field5.PointerManaged(i), field6.PointerManaged(i), field7.PointerManaged(i), field8.PointerManaged(i), field9.PointerManaged(i), field10.PointerManaged(i), field11.PointerManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSharedManaged(i), field1.PointerSharedManaged(i), field2.PointerSharedManaged(i), field3.PointerSharedManaged(i), field4.PointerSharedManaged(i), field5.PointerSharedManaged(i), field6.PointerSharedManaged(i), field7.PointerSharedManaged(i), field8.PointerSharedManaged(i), field9.PointerSharedManaged(i), field10.PointerSharedManaged(i), field11.PointerSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseManaged(i), field1.PointerSparseManaged(i), field2.PointerSparseManaged(i), field3.PointerSparseManaged(i), field4.PointerSparseManaged(i), field5.PointerSparseManaged(i), field6.PointerSparseManaged(i), field7.PointerSparseManaged(i), field8.PointerSparseManaged(i), field9.PointerSparseManaged(i), field10.PointerSparseManaged(i), field11.PointerSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseSharedManaged(i), field1.PointerSparseSharedManaged(i), field2.PointerSparseSharedManaged(i), field3.PointerSparseSharedManaged(i), field4.PointerSparseSharedManaged(i), field5.PointerSparseSharedManaged(i), field6.PointerSparseSharedManaged(i), field7.PointerSparseSharedManaged(i), field8.PointerSparseSharedManaged(i), field9.PointerSparseSharedManaged(i), field10.PointerSparseSharedManaged(i), field11.PointerSparseSharedManaged(i));
+        }
     }
 
     /// <summary>
@@ -185,15 +811,93 @@ public static void Each<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(Iter i
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8); byte* pointer9 = (byte*)it.GetPointer<T9>(9); byte* pointer10 = (byte*)it.GetPointer<T10>(10); byte* pointer11 = (byte*)it.GetPointer<T11>(11);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8); int step9 = it.Step<T9>(9); int step10 = it.Step<T10>(10); int step11 = it.Step<T11>(11);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8); FieldData<T9> field9 = it.GetFieldData<T9>(9); FieldData<T10> field10 = it.GetFieldData<T10>(10); FieldData<T11> field11 = it.GetFieldData<T11>(11);
+        IterationTechnique flags = it.GetIterationTechnique(12);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8], pointer9 = &pointer9[step9], pointer10 = &pointer10[step10], pointer11 = &pointer11[step11])
-            callback(it, i, (T0*)pointer0, (T1*)pointer1, (T2*)pointer2, (T3*)pointer3, (T4*)pointer4, (T5*)pointer5, (T6*)pointer6, (T7*)pointer7, (T8*)pointer8, (T9*)pointer9, (T10*)pointer10, (T11*)pointer11);
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>() || RuntimeHelpers.IsReferenceOrContainsReferences<T9>() || RuntimeHelpers.IsReferenceOrContainsReferences<T10>() || RuntimeHelpers.IsReferenceOrContainsReferences<T11>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerUnmanaged(i), field1.PointerUnmanaged(i), field2.PointerUnmanaged(i), field3.PointerUnmanaged(i), field4.PointerUnmanaged(i), field5.PointerUnmanaged(i), field6.PointerUnmanaged(i), field7.PointerUnmanaged(i), field8.PointerUnmanaged(i), field9.PointerUnmanaged(i), field10.PointerUnmanaged(i), field11.PointerUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSharedUnmanaged(i), field1.PointerSharedUnmanaged(i), field2.PointerSharedUnmanaged(i), field3.PointerSharedUnmanaged(i), field4.PointerSharedUnmanaged(i), field5.PointerSharedUnmanaged(i), field6.PointerSharedUnmanaged(i), field7.PointerSharedUnmanaged(i), field8.PointerSharedUnmanaged(i), field9.PointerSharedUnmanaged(i), field10.PointerSharedUnmanaged(i), field11.PointerSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSparseUnmanaged(i), field1.PointerSparseUnmanaged(i), field2.PointerSparseUnmanaged(i), field3.PointerSparseUnmanaged(i), field4.PointerSparseUnmanaged(i), field5.PointerSparseUnmanaged(i), field6.PointerSparseUnmanaged(i), field7.PointerSparseUnmanaged(i), field8.PointerSparseUnmanaged(i), field9.PointerSparseUnmanaged(i), field10.PointerSparseUnmanaged(i), field11.PointerSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSparseSharedUnmanaged(i), field1.PointerSparseSharedUnmanaged(i), field2.PointerSparseSharedUnmanaged(i), field3.PointerSparseSharedUnmanaged(i), field4.PointerSparseSharedUnmanaged(i), field5.PointerSparseSharedUnmanaged(i), field6.PointerSparseSharedUnmanaged(i), field7.PointerSparseSharedUnmanaged(i), field8.PointerSparseSharedUnmanaged(i), field9.PointerSparseSharedUnmanaged(i), field10.PointerSparseSharedUnmanaged(i), field11.PointerSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerManaged(i), field1.PointerManaged(i), field2.PointerManaged(i), field3.PointerManaged(i), field4.PointerManaged(i), field5.PointerManaged(i), field6.PointerManaged(i), field7.PointerManaged(i), field8.PointerManaged(i), field9.PointerManaged(i), field10.PointerManaged(i), field11.PointerManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSharedManaged(i), field1.PointerSharedManaged(i), field2.PointerSharedManaged(i), field3.PointerSharedManaged(i), field4.PointerSharedManaged(i), field5.PointerSharedManaged(i), field6.PointerSharedManaged(i), field7.PointerSharedManaged(i), field8.PointerSharedManaged(i), field9.PointerSharedManaged(i), field10.PointerSharedManaged(i), field11.PointerSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSparseManaged(i), field1.PointerSparseManaged(i), field2.PointerSparseManaged(i), field3.PointerSparseManaged(i), field4.PointerSparseManaged(i), field5.PointerSparseManaged(i), field6.PointerSparseManaged(i), field7.PointerSparseManaged(i), field8.PointerSparseManaged(i), field9.PointerSparseManaged(i), field10.PointerSparseManaged(i), field11.PointerSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSparseSharedManaged(i), field1.PointerSparseSharedManaged(i), field2.PointerSparseSharedManaged(i), field3.PointerSparseSharedManaged(i), field4.PointerSparseSharedManaged(i), field5.PointerSparseSharedManaged(i), field6.PointerSparseSharedManaged(i), field7.PointerSparseSharedManaged(i), field8.PointerSparseSharedManaged(i), field9.PointerSparseSharedManaged(i), field10.PointerSparseSharedManaged(i), field11.PointerSparseSharedManaged(i));
+        }
     }
 
     /// <summary>
@@ -206,15 +910,93 @@ public static void Each<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(Iter i
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8); byte* pointer9 = (byte*)it.GetPointer<T9>(9); byte* pointer10 = (byte*)it.GetPointer<T10>(10); byte* pointer11 = (byte*)it.GetPointer<T11>(11);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8); int step9 = it.Step<T9>(9); int step10 = it.Step<T10>(10); int step11 = it.Step<T11>(11);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8); FieldData<T9> field9 = it.GetFieldData<T9>(9); FieldData<T10> field10 = it.GetFieldData<T10>(10); FieldData<T11> field11 = it.GetFieldData<T11>(11);
+        IterationTechnique flags = it.GetIterationTechnique(12);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8], pointer9 = &pointer9[step9], pointer10 = &pointer10[step10], pointer11 = &pointer11[step11])
-            callback((T0*)pointer0, (T1*)pointer1, (T2*)pointer2, (T3*)pointer3, (T4*)pointer4, (T5*)pointer5, (T6*)pointer6, (T7*)pointer7, (T8*)pointer8, (T9*)pointer9, (T10*)pointer10, (T11*)pointer11);
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>() || RuntimeHelpers.IsReferenceOrContainsReferences<T9>() || RuntimeHelpers.IsReferenceOrContainsReferences<T10>() || RuntimeHelpers.IsReferenceOrContainsReferences<T11>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerUnmanaged(i), field1.PointerUnmanaged(i), field2.PointerUnmanaged(i), field3.PointerUnmanaged(i), field4.PointerUnmanaged(i), field5.PointerUnmanaged(i), field6.PointerUnmanaged(i), field7.PointerUnmanaged(i), field8.PointerUnmanaged(i), field9.PointerUnmanaged(i), field10.PointerUnmanaged(i), field11.PointerUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSharedUnmanaged(i), field1.PointerSharedUnmanaged(i), field2.PointerSharedUnmanaged(i), field3.PointerSharedUnmanaged(i), field4.PointerSharedUnmanaged(i), field5.PointerSharedUnmanaged(i), field6.PointerSharedUnmanaged(i), field7.PointerSharedUnmanaged(i), field8.PointerSharedUnmanaged(i), field9.PointerSharedUnmanaged(i), field10.PointerSharedUnmanaged(i), field11.PointerSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSparseUnmanaged(i), field1.PointerSparseUnmanaged(i), field2.PointerSparseUnmanaged(i), field3.PointerSparseUnmanaged(i), field4.PointerSparseUnmanaged(i), field5.PointerSparseUnmanaged(i), field6.PointerSparseUnmanaged(i), field7.PointerSparseUnmanaged(i), field8.PointerSparseUnmanaged(i), field9.PointerSparseUnmanaged(i), field10.PointerSparseUnmanaged(i), field11.PointerSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSparseSharedUnmanaged(i), field1.PointerSparseSharedUnmanaged(i), field2.PointerSparseSharedUnmanaged(i), field3.PointerSparseSharedUnmanaged(i), field4.PointerSparseSharedUnmanaged(i), field5.PointerSparseSharedUnmanaged(i), field6.PointerSparseSharedUnmanaged(i), field7.PointerSparseSharedUnmanaged(i), field8.PointerSparseSharedUnmanaged(i), field9.PointerSparseSharedUnmanaged(i), field10.PointerSparseSharedUnmanaged(i), field11.PointerSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerManaged(i), field1.PointerManaged(i), field2.PointerManaged(i), field3.PointerManaged(i), field4.PointerManaged(i), field5.PointerManaged(i), field6.PointerManaged(i), field7.PointerManaged(i), field8.PointerManaged(i), field9.PointerManaged(i), field10.PointerManaged(i), field11.PointerManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSharedManaged(i), field1.PointerSharedManaged(i), field2.PointerSharedManaged(i), field3.PointerSharedManaged(i), field4.PointerSharedManaged(i), field5.PointerSharedManaged(i), field6.PointerSharedManaged(i), field7.PointerSharedManaged(i), field8.PointerSharedManaged(i), field9.PointerSharedManaged(i), field10.PointerSharedManaged(i), field11.PointerSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSparseManaged(i), field1.PointerSparseManaged(i), field2.PointerSparseManaged(i), field3.PointerSparseManaged(i), field4.PointerSparseManaged(i), field5.PointerSparseManaged(i), field6.PointerSparseManaged(i), field7.PointerSparseManaged(i), field8.PointerSparseManaged(i), field9.PointerSparseManaged(i), field10.PointerSparseManaged(i), field11.PointerSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSparseSharedManaged(i), field1.PointerSparseSharedManaged(i), field2.PointerSparseSharedManaged(i), field3.PointerSparseSharedManaged(i), field4.PointerSparseSharedManaged(i), field5.PointerSparseSharedManaged(i), field6.PointerSparseSharedManaged(i), field7.PointerSparseSharedManaged(i), field8.PointerSparseSharedManaged(i), field9.PointerSparseSharedManaged(i), field10.PointerSparseSharedManaged(i), field11.PointerSparseSharedManaged(i));
+        }
     }
 
     /// <summary>
@@ -227,15 +1009,93 @@ public static void Each<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(Iter i
     {
         int count = it.Handle->count; Ecs.Assert(it.Handle->count > 0, "No entities returned, use Iter() or Each() without the entity argument instead.");
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8); byte* pointer9 = (byte*)it.GetPointer<T9>(9); byte* pointer10 = (byte*)it.GetPointer<T10>(10); byte* pointer11 = (byte*)it.GetPointer<T11>(11);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8); int step9 = it.Step<T9>(9); int step10 = it.Step<T10>(10); int step11 = it.Step<T11>(11);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8); FieldData<T9> field9 = it.GetFieldData<T9>(9); FieldData<T10> field10 = it.GetFieldData<T10>(10); FieldData<T11> field11 = it.GetFieldData<T11>(11);
+        IterationTechnique flags = it.GetIterationTechnique(12);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8], pointer9 = &pointer9[step9], pointer10 = &pointer10[step10], pointer11 = &pointer11[step11])
-            callback(new Entity(it.Handle->world, it.Handle->entities[i]), (T0*)pointer0, (T1*)pointer1, (T2*)pointer2, (T3*)pointer3, (T4*)pointer4, (T5*)pointer5, (T6*)pointer6, (T7*)pointer7, (T8*)pointer8, (T9*)pointer9, (T10*)pointer10, (T11*)pointer11);
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>() || RuntimeHelpers.IsReferenceOrContainsReferences<T9>() || RuntimeHelpers.IsReferenceOrContainsReferences<T10>() || RuntimeHelpers.IsReferenceOrContainsReferences<T11>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerUnmanaged(i), field1.PointerUnmanaged(i), field2.PointerUnmanaged(i), field3.PointerUnmanaged(i), field4.PointerUnmanaged(i), field5.PointerUnmanaged(i), field6.PointerUnmanaged(i), field7.PointerUnmanaged(i), field8.PointerUnmanaged(i), field9.PointerUnmanaged(i), field10.PointerUnmanaged(i), field11.PointerUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSharedUnmanaged(i), field1.PointerSharedUnmanaged(i), field2.PointerSharedUnmanaged(i), field3.PointerSharedUnmanaged(i), field4.PointerSharedUnmanaged(i), field5.PointerSharedUnmanaged(i), field6.PointerSharedUnmanaged(i), field7.PointerSharedUnmanaged(i), field8.PointerSharedUnmanaged(i), field9.PointerSharedUnmanaged(i), field10.PointerSharedUnmanaged(i), field11.PointerSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseUnmanaged(i), field1.PointerSparseUnmanaged(i), field2.PointerSparseUnmanaged(i), field3.PointerSparseUnmanaged(i), field4.PointerSparseUnmanaged(i), field5.PointerSparseUnmanaged(i), field6.PointerSparseUnmanaged(i), field7.PointerSparseUnmanaged(i), field8.PointerSparseUnmanaged(i), field9.PointerSparseUnmanaged(i), field10.PointerSparseUnmanaged(i), field11.PointerSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseSharedUnmanaged(i), field1.PointerSparseSharedUnmanaged(i), field2.PointerSparseSharedUnmanaged(i), field3.PointerSparseSharedUnmanaged(i), field4.PointerSparseSharedUnmanaged(i), field5.PointerSparseSharedUnmanaged(i), field6.PointerSparseSharedUnmanaged(i), field7.PointerSparseSharedUnmanaged(i), field8.PointerSparseSharedUnmanaged(i), field9.PointerSparseSharedUnmanaged(i), field10.PointerSparseSharedUnmanaged(i), field11.PointerSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerManaged(i), field1.PointerManaged(i), field2.PointerManaged(i), field3.PointerManaged(i), field4.PointerManaged(i), field5.PointerManaged(i), field6.PointerManaged(i), field7.PointerManaged(i), field8.PointerManaged(i), field9.PointerManaged(i), field10.PointerManaged(i), field11.PointerManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSharedManaged(i), field1.PointerSharedManaged(i), field2.PointerSharedManaged(i), field3.PointerSharedManaged(i), field4.PointerSharedManaged(i), field5.PointerSharedManaged(i), field6.PointerSharedManaged(i), field7.PointerSharedManaged(i), field8.PointerSharedManaged(i), field9.PointerSharedManaged(i), field10.PointerSharedManaged(i), field11.PointerSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseManaged(i), field1.PointerSparseManaged(i), field2.PointerSparseManaged(i), field3.PointerSparseManaged(i), field4.PointerSparseManaged(i), field5.PointerSparseManaged(i), field6.PointerSparseManaged(i), field7.PointerSparseManaged(i), field8.PointerSparseManaged(i), field9.PointerSparseManaged(i), field10.PointerSparseManaged(i), field11.PointerSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseSharedManaged(i), field1.PointerSparseSharedManaged(i), field2.PointerSparseSharedManaged(i), field3.PointerSparseSharedManaged(i), field4.PointerSparseSharedManaged(i), field5.PointerSparseSharedManaged(i), field6.PointerSparseSharedManaged(i), field7.PointerSparseSharedManaged(i), field8.PointerSparseSharedManaged(i), field9.PointerSparseSharedManaged(i), field10.PointerSparseSharedManaged(i), field11.PointerSparseSharedManaged(i));
+        }
     }
 
     /// <summary>
@@ -248,14 +1108,92 @@ public static void Each<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(Iter i
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8); byte* pointer9 = (byte*)it.GetPointer<T9>(9); byte* pointer10 = (byte*)it.GetPointer<T10>(10); byte* pointer11 = (byte*)it.GetPointer<T11>(11);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8); int step9 = it.Step<T9>(9); int step10 = it.Step<T10>(10); int step11 = it.Step<T11>(11);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8); FieldData<T9> field9 = it.GetFieldData<T9>(9); FieldData<T10> field10 = it.GetFieldData<T10>(10); FieldData<T11> field11 = it.GetFieldData<T11>(11);
+        IterationTechnique flags = it.GetIterationTechnique(12);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8], pointer9 = &pointer9[step9], pointer10 = &pointer10[step10], pointer11 = &pointer11[step11])
-            callback(it, i, (T0*)pointer0, (T1*)pointer1, (T2*)pointer2, (T3*)pointer3, (T4*)pointer4, (T5*)pointer5, (T6*)pointer6, (T7*)pointer7, (T8*)pointer8, (T9*)pointer9, (T10*)pointer10, (T11*)pointer11);
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>() || RuntimeHelpers.IsReferenceOrContainsReferences<T9>() || RuntimeHelpers.IsReferenceOrContainsReferences<T10>() || RuntimeHelpers.IsReferenceOrContainsReferences<T11>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerUnmanaged(i), field1.PointerUnmanaged(i), field2.PointerUnmanaged(i), field3.PointerUnmanaged(i), field4.PointerUnmanaged(i), field5.PointerUnmanaged(i), field6.PointerUnmanaged(i), field7.PointerUnmanaged(i), field8.PointerUnmanaged(i), field9.PointerUnmanaged(i), field10.PointerUnmanaged(i), field11.PointerUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSharedUnmanaged(i), field1.PointerSharedUnmanaged(i), field2.PointerSharedUnmanaged(i), field3.PointerSharedUnmanaged(i), field4.PointerSharedUnmanaged(i), field5.PointerSharedUnmanaged(i), field6.PointerSharedUnmanaged(i), field7.PointerSharedUnmanaged(i), field8.PointerSharedUnmanaged(i), field9.PointerSharedUnmanaged(i), field10.PointerSharedUnmanaged(i), field11.PointerSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSparseUnmanaged(i), field1.PointerSparseUnmanaged(i), field2.PointerSparseUnmanaged(i), field3.PointerSparseUnmanaged(i), field4.PointerSparseUnmanaged(i), field5.PointerSparseUnmanaged(i), field6.PointerSparseUnmanaged(i), field7.PointerSparseUnmanaged(i), field8.PointerSparseUnmanaged(i), field9.PointerSparseUnmanaged(i), field10.PointerSparseUnmanaged(i), field11.PointerSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSparseSharedUnmanaged(i), field1.PointerSparseSharedUnmanaged(i), field2.PointerSparseSharedUnmanaged(i), field3.PointerSparseSharedUnmanaged(i), field4.PointerSparseSharedUnmanaged(i), field5.PointerSparseSharedUnmanaged(i), field6.PointerSparseSharedUnmanaged(i), field7.PointerSparseSharedUnmanaged(i), field8.PointerSparseSharedUnmanaged(i), field9.PointerSparseSharedUnmanaged(i), field10.PointerSparseSharedUnmanaged(i), field11.PointerSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerManaged(i), field1.PointerManaged(i), field2.PointerManaged(i), field3.PointerManaged(i), field4.PointerManaged(i), field5.PointerManaged(i), field6.PointerManaged(i), field7.PointerManaged(i), field8.PointerManaged(i), field9.PointerManaged(i), field10.PointerManaged(i), field11.PointerManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSharedManaged(i), field1.PointerSharedManaged(i), field2.PointerSharedManaged(i), field3.PointerSharedManaged(i), field4.PointerSharedManaged(i), field5.PointerSharedManaged(i), field6.PointerSharedManaged(i), field7.PointerSharedManaged(i), field8.PointerSharedManaged(i), field9.PointerSharedManaged(i), field10.PointerSharedManaged(i), field11.PointerSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSparseManaged(i), field1.PointerSparseManaged(i), field2.PointerSparseManaged(i), field3.PointerSparseManaged(i), field4.PointerSparseManaged(i), field5.PointerSparseManaged(i), field6.PointerSparseManaged(i), field7.PointerSparseManaged(i), field8.PointerSparseManaged(i), field9.PointerSparseManaged(i), field10.PointerSparseManaged(i), field11.PointerSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSparseSharedManaged(i), field1.PointerSparseSharedManaged(i), field2.PointerSparseSharedManaged(i), field3.PointerSparseSharedManaged(i), field4.PointerSparseSharedManaged(i), field5.PointerSparseSharedManaged(i), field6.PointerSparseSharedManaged(i), field7.PointerSparseSharedManaged(i), field8.PointerSparseSharedManaged(i), field9.PointerSparseSharedManaged(i), field10.PointerSparseSharedManaged(i), field11.PointerSparseSharedManaged(i));
+        }
     }
 }
\ No newline at end of file
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/Invoker/Each/Iterator/T13.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/Invoker/Each/Iterator/T13.g.cs
index b03f8aae..c5706a17 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/Invoker/Each/Iterator/T13.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/Invoker/Each/Iterator/T13.g.cs
@@ -1,5 +1,7 @@
 // Each/Iterator/T13.g.cs
 // File was auto-generated by /_/src/Flecs.NET.Codegen/Generators/Invoker.cs
+using System;
+using System.Runtime.CompilerServices;
 using Flecs.NET.Utilities;
 using static Flecs.NET.Bindings.flecs;
 
@@ -17,15 +19,93 @@ public static void Each<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(I
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8); byte* pointer9 = (byte*)it.GetPointer<T9>(9); byte* pointer10 = (byte*)it.GetPointer<T10>(10); byte* pointer11 = (byte*)it.GetPointer<T11>(11); byte* pointer12 = (byte*)it.GetPointer<T12>(12);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8); int step9 = it.Step<T9>(9); int step10 = it.Step<T10>(10); int step11 = it.Step<T11>(11); int step12 = it.Step<T12>(12);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8); FieldData<T9> field9 = it.GetFieldData<T9>(9); FieldData<T10> field10 = it.GetFieldData<T10>(10); FieldData<T11> field11 = it.GetFieldData<T11>(11); FieldData<T12> field12 = it.GetFieldData<T12>(12);
+        IterationTechnique flags = it.GetIterationTechnique(13);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8], pointer9 = &pointer9[step9], pointer10 = &pointer10[step10], pointer11 = &pointer11[step11], pointer12 = &pointer12[step12])
-            callback(ref Managed.GetTypeRef<T0>(pointer0), ref Managed.GetTypeRef<T1>(pointer1), ref Managed.GetTypeRef<T2>(pointer2), ref Managed.GetTypeRef<T3>(pointer3), ref Managed.GetTypeRef<T4>(pointer4), ref Managed.GetTypeRef<T5>(pointer5), ref Managed.GetTypeRef<T6>(pointer6), ref Managed.GetTypeRef<T7>(pointer7), ref Managed.GetTypeRef<T8>(pointer8), ref Managed.GetTypeRef<T9>(pointer9), ref Managed.GetTypeRef<T10>(pointer10), ref Managed.GetTypeRef<T11>(pointer11), ref Managed.GetTypeRef<T12>(pointer12));
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>() || RuntimeHelpers.IsReferenceOrContainsReferences<T9>() || RuntimeHelpers.IsReferenceOrContainsReferences<T10>() || RuntimeHelpers.IsReferenceOrContainsReferences<T11>() || RuntimeHelpers.IsReferenceOrContainsReferences<T12>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefUnmanaged(i), ref field1.RefUnmanaged(i), ref field2.RefUnmanaged(i), ref field3.RefUnmanaged(i), ref field4.RefUnmanaged(i), ref field5.RefUnmanaged(i), ref field6.RefUnmanaged(i), ref field7.RefUnmanaged(i), ref field8.RefUnmanaged(i), ref field9.RefUnmanaged(i), ref field10.RefUnmanaged(i), ref field11.RefUnmanaged(i), ref field12.RefUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSharedUnmanaged(i), ref field1.RefSharedUnmanaged(i), ref field2.RefSharedUnmanaged(i), ref field3.RefSharedUnmanaged(i), ref field4.RefSharedUnmanaged(i), ref field5.RefSharedUnmanaged(i), ref field6.RefSharedUnmanaged(i), ref field7.RefSharedUnmanaged(i), ref field8.RefSharedUnmanaged(i), ref field9.RefSharedUnmanaged(i), ref field10.RefSharedUnmanaged(i), ref field11.RefSharedUnmanaged(i), ref field12.RefSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSparseUnmanaged(i), ref field1.RefSparseUnmanaged(i), ref field2.RefSparseUnmanaged(i), ref field3.RefSparseUnmanaged(i), ref field4.RefSparseUnmanaged(i), ref field5.RefSparseUnmanaged(i), ref field6.RefSparseUnmanaged(i), ref field7.RefSparseUnmanaged(i), ref field8.RefSparseUnmanaged(i), ref field9.RefSparseUnmanaged(i), ref field10.RefSparseUnmanaged(i), ref field11.RefSparseUnmanaged(i), ref field12.RefSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSparseSharedUnmanaged(i), ref field1.RefSparseSharedUnmanaged(i), ref field2.RefSparseSharedUnmanaged(i), ref field3.RefSparseSharedUnmanaged(i), ref field4.RefSparseSharedUnmanaged(i), ref field5.RefSparseSharedUnmanaged(i), ref field6.RefSparseSharedUnmanaged(i), ref field7.RefSparseSharedUnmanaged(i), ref field8.RefSparseSharedUnmanaged(i), ref field9.RefSparseSharedUnmanaged(i), ref field10.RefSparseSharedUnmanaged(i), ref field11.RefSparseSharedUnmanaged(i), ref field12.RefSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefManaged(i), ref field1.RefManaged(i), ref field2.RefManaged(i), ref field3.RefManaged(i), ref field4.RefManaged(i), ref field5.RefManaged(i), ref field6.RefManaged(i), ref field7.RefManaged(i), ref field8.RefManaged(i), ref field9.RefManaged(i), ref field10.RefManaged(i), ref field11.RefManaged(i), ref field12.RefManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSharedManaged(i), ref field1.RefSharedManaged(i), ref field2.RefSharedManaged(i), ref field3.RefSharedManaged(i), ref field4.RefSharedManaged(i), ref field5.RefSharedManaged(i), ref field6.RefSharedManaged(i), ref field7.RefSharedManaged(i), ref field8.RefSharedManaged(i), ref field9.RefSharedManaged(i), ref field10.RefSharedManaged(i), ref field11.RefSharedManaged(i), ref field12.RefSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSparseManaged(i), ref field1.RefSparseManaged(i), ref field2.RefSparseManaged(i), ref field3.RefSparseManaged(i), ref field4.RefSparseManaged(i), ref field5.RefSparseManaged(i), ref field6.RefSparseManaged(i), ref field7.RefSparseManaged(i), ref field8.RefSparseManaged(i), ref field9.RefSparseManaged(i), ref field10.RefSparseManaged(i), ref field11.RefSparseManaged(i), ref field12.RefSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSparseSharedManaged(i), ref field1.RefSparseSharedManaged(i), ref field2.RefSparseSharedManaged(i), ref field3.RefSparseSharedManaged(i), ref field4.RefSparseSharedManaged(i), ref field5.RefSparseSharedManaged(i), ref field6.RefSparseSharedManaged(i), ref field7.RefSparseSharedManaged(i), ref field8.RefSparseSharedManaged(i), ref field9.RefSparseSharedManaged(i), ref field10.RefSparseSharedManaged(i), ref field11.RefSparseSharedManaged(i), ref field12.RefSparseSharedManaged(i));
+        }
     }
 
     /// <summary>
@@ -38,15 +118,93 @@ public static void Each<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(I
     {
         int count = it.Handle->count; Ecs.Assert(it.Handle->count > 0, "No entities returned, use Iter() or Each() without the entity argument instead.");
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8); byte* pointer9 = (byte*)it.GetPointer<T9>(9); byte* pointer10 = (byte*)it.GetPointer<T10>(10); byte* pointer11 = (byte*)it.GetPointer<T11>(11); byte* pointer12 = (byte*)it.GetPointer<T12>(12);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8); int step9 = it.Step<T9>(9); int step10 = it.Step<T10>(10); int step11 = it.Step<T11>(11); int step12 = it.Step<T12>(12);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8); FieldData<T9> field9 = it.GetFieldData<T9>(9); FieldData<T10> field10 = it.GetFieldData<T10>(10); FieldData<T11> field11 = it.GetFieldData<T11>(11); FieldData<T12> field12 = it.GetFieldData<T12>(12);
+        IterationTechnique flags = it.GetIterationTechnique(13);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8], pointer9 = &pointer9[step9], pointer10 = &pointer10[step10], pointer11 = &pointer11[step11], pointer12 = &pointer12[step12])
-            callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref Managed.GetTypeRef<T0>(pointer0), ref Managed.GetTypeRef<T1>(pointer1), ref Managed.GetTypeRef<T2>(pointer2), ref Managed.GetTypeRef<T3>(pointer3), ref Managed.GetTypeRef<T4>(pointer4), ref Managed.GetTypeRef<T5>(pointer5), ref Managed.GetTypeRef<T6>(pointer6), ref Managed.GetTypeRef<T7>(pointer7), ref Managed.GetTypeRef<T8>(pointer8), ref Managed.GetTypeRef<T9>(pointer9), ref Managed.GetTypeRef<T10>(pointer10), ref Managed.GetTypeRef<T11>(pointer11), ref Managed.GetTypeRef<T12>(pointer12));
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>() || RuntimeHelpers.IsReferenceOrContainsReferences<T9>() || RuntimeHelpers.IsReferenceOrContainsReferences<T10>() || RuntimeHelpers.IsReferenceOrContainsReferences<T11>() || RuntimeHelpers.IsReferenceOrContainsReferences<T12>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefUnmanaged(i), ref field1.RefUnmanaged(i), ref field2.RefUnmanaged(i), ref field3.RefUnmanaged(i), ref field4.RefUnmanaged(i), ref field5.RefUnmanaged(i), ref field6.RefUnmanaged(i), ref field7.RefUnmanaged(i), ref field8.RefUnmanaged(i), ref field9.RefUnmanaged(i), ref field10.RefUnmanaged(i), ref field11.RefUnmanaged(i), ref field12.RefUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSharedUnmanaged(i), ref field1.RefSharedUnmanaged(i), ref field2.RefSharedUnmanaged(i), ref field3.RefSharedUnmanaged(i), ref field4.RefSharedUnmanaged(i), ref field5.RefSharedUnmanaged(i), ref field6.RefSharedUnmanaged(i), ref field7.RefSharedUnmanaged(i), ref field8.RefSharedUnmanaged(i), ref field9.RefSharedUnmanaged(i), ref field10.RefSharedUnmanaged(i), ref field11.RefSharedUnmanaged(i), ref field12.RefSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseUnmanaged(i), ref field1.RefSparseUnmanaged(i), ref field2.RefSparseUnmanaged(i), ref field3.RefSparseUnmanaged(i), ref field4.RefSparseUnmanaged(i), ref field5.RefSparseUnmanaged(i), ref field6.RefSparseUnmanaged(i), ref field7.RefSparseUnmanaged(i), ref field8.RefSparseUnmanaged(i), ref field9.RefSparseUnmanaged(i), ref field10.RefSparseUnmanaged(i), ref field11.RefSparseUnmanaged(i), ref field12.RefSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseSharedUnmanaged(i), ref field1.RefSparseSharedUnmanaged(i), ref field2.RefSparseSharedUnmanaged(i), ref field3.RefSparseSharedUnmanaged(i), ref field4.RefSparseSharedUnmanaged(i), ref field5.RefSparseSharedUnmanaged(i), ref field6.RefSparseSharedUnmanaged(i), ref field7.RefSparseSharedUnmanaged(i), ref field8.RefSparseSharedUnmanaged(i), ref field9.RefSparseSharedUnmanaged(i), ref field10.RefSparseSharedUnmanaged(i), ref field11.RefSparseSharedUnmanaged(i), ref field12.RefSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefManaged(i), ref field1.RefManaged(i), ref field2.RefManaged(i), ref field3.RefManaged(i), ref field4.RefManaged(i), ref field5.RefManaged(i), ref field6.RefManaged(i), ref field7.RefManaged(i), ref field8.RefManaged(i), ref field9.RefManaged(i), ref field10.RefManaged(i), ref field11.RefManaged(i), ref field12.RefManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSharedManaged(i), ref field1.RefSharedManaged(i), ref field2.RefSharedManaged(i), ref field3.RefSharedManaged(i), ref field4.RefSharedManaged(i), ref field5.RefSharedManaged(i), ref field6.RefSharedManaged(i), ref field7.RefSharedManaged(i), ref field8.RefSharedManaged(i), ref field9.RefSharedManaged(i), ref field10.RefSharedManaged(i), ref field11.RefSharedManaged(i), ref field12.RefSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseManaged(i), ref field1.RefSparseManaged(i), ref field2.RefSparseManaged(i), ref field3.RefSparseManaged(i), ref field4.RefSparseManaged(i), ref field5.RefSparseManaged(i), ref field6.RefSparseManaged(i), ref field7.RefSparseManaged(i), ref field8.RefSparseManaged(i), ref field9.RefSparseManaged(i), ref field10.RefSparseManaged(i), ref field11.RefSparseManaged(i), ref field12.RefSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseSharedManaged(i), ref field1.RefSparseSharedManaged(i), ref field2.RefSparseSharedManaged(i), ref field3.RefSparseSharedManaged(i), ref field4.RefSparseSharedManaged(i), ref field5.RefSparseSharedManaged(i), ref field6.RefSparseSharedManaged(i), ref field7.RefSparseSharedManaged(i), ref field8.RefSparseSharedManaged(i), ref field9.RefSparseSharedManaged(i), ref field10.RefSparseSharedManaged(i), ref field11.RefSparseSharedManaged(i), ref field12.RefSparseSharedManaged(i));
+        }
     }
 
     /// <summary>
@@ -59,15 +217,93 @@ public static void Each<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(I
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8); byte* pointer9 = (byte*)it.GetPointer<T9>(9); byte* pointer10 = (byte*)it.GetPointer<T10>(10); byte* pointer11 = (byte*)it.GetPointer<T11>(11); byte* pointer12 = (byte*)it.GetPointer<T12>(12);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8); int step9 = it.Step<T9>(9); int step10 = it.Step<T10>(10); int step11 = it.Step<T11>(11); int step12 = it.Step<T12>(12);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8); FieldData<T9> field9 = it.GetFieldData<T9>(9); FieldData<T10> field10 = it.GetFieldData<T10>(10); FieldData<T11> field11 = it.GetFieldData<T11>(11); FieldData<T12> field12 = it.GetFieldData<T12>(12);
+        IterationTechnique flags = it.GetIterationTechnique(13);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8], pointer9 = &pointer9[step9], pointer10 = &pointer10[step10], pointer11 = &pointer11[step11], pointer12 = &pointer12[step12])
-            callback(it, i, ref Managed.GetTypeRef<T0>(pointer0), ref Managed.GetTypeRef<T1>(pointer1), ref Managed.GetTypeRef<T2>(pointer2), ref Managed.GetTypeRef<T3>(pointer3), ref Managed.GetTypeRef<T4>(pointer4), ref Managed.GetTypeRef<T5>(pointer5), ref Managed.GetTypeRef<T6>(pointer6), ref Managed.GetTypeRef<T7>(pointer7), ref Managed.GetTypeRef<T8>(pointer8), ref Managed.GetTypeRef<T9>(pointer9), ref Managed.GetTypeRef<T10>(pointer10), ref Managed.GetTypeRef<T11>(pointer11), ref Managed.GetTypeRef<T12>(pointer12));
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>() || RuntimeHelpers.IsReferenceOrContainsReferences<T9>() || RuntimeHelpers.IsReferenceOrContainsReferences<T10>() || RuntimeHelpers.IsReferenceOrContainsReferences<T11>() || RuntimeHelpers.IsReferenceOrContainsReferences<T12>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefUnmanaged(i), ref field1.RefUnmanaged(i), ref field2.RefUnmanaged(i), ref field3.RefUnmanaged(i), ref field4.RefUnmanaged(i), ref field5.RefUnmanaged(i), ref field6.RefUnmanaged(i), ref field7.RefUnmanaged(i), ref field8.RefUnmanaged(i), ref field9.RefUnmanaged(i), ref field10.RefUnmanaged(i), ref field11.RefUnmanaged(i), ref field12.RefUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSharedUnmanaged(i), ref field1.RefSharedUnmanaged(i), ref field2.RefSharedUnmanaged(i), ref field3.RefSharedUnmanaged(i), ref field4.RefSharedUnmanaged(i), ref field5.RefSharedUnmanaged(i), ref field6.RefSharedUnmanaged(i), ref field7.RefSharedUnmanaged(i), ref field8.RefSharedUnmanaged(i), ref field9.RefSharedUnmanaged(i), ref field10.RefSharedUnmanaged(i), ref field11.RefSharedUnmanaged(i), ref field12.RefSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSparseUnmanaged(i), ref field1.RefSparseUnmanaged(i), ref field2.RefSparseUnmanaged(i), ref field3.RefSparseUnmanaged(i), ref field4.RefSparseUnmanaged(i), ref field5.RefSparseUnmanaged(i), ref field6.RefSparseUnmanaged(i), ref field7.RefSparseUnmanaged(i), ref field8.RefSparseUnmanaged(i), ref field9.RefSparseUnmanaged(i), ref field10.RefSparseUnmanaged(i), ref field11.RefSparseUnmanaged(i), ref field12.RefSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSparseSharedUnmanaged(i), ref field1.RefSparseSharedUnmanaged(i), ref field2.RefSparseSharedUnmanaged(i), ref field3.RefSparseSharedUnmanaged(i), ref field4.RefSparseSharedUnmanaged(i), ref field5.RefSparseSharedUnmanaged(i), ref field6.RefSparseSharedUnmanaged(i), ref field7.RefSparseSharedUnmanaged(i), ref field8.RefSparseSharedUnmanaged(i), ref field9.RefSparseSharedUnmanaged(i), ref field10.RefSparseSharedUnmanaged(i), ref field11.RefSparseSharedUnmanaged(i), ref field12.RefSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefManaged(i), ref field1.RefManaged(i), ref field2.RefManaged(i), ref field3.RefManaged(i), ref field4.RefManaged(i), ref field5.RefManaged(i), ref field6.RefManaged(i), ref field7.RefManaged(i), ref field8.RefManaged(i), ref field9.RefManaged(i), ref field10.RefManaged(i), ref field11.RefManaged(i), ref field12.RefManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSharedManaged(i), ref field1.RefSharedManaged(i), ref field2.RefSharedManaged(i), ref field3.RefSharedManaged(i), ref field4.RefSharedManaged(i), ref field5.RefSharedManaged(i), ref field6.RefSharedManaged(i), ref field7.RefSharedManaged(i), ref field8.RefSharedManaged(i), ref field9.RefSharedManaged(i), ref field10.RefSharedManaged(i), ref field11.RefSharedManaged(i), ref field12.RefSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSparseManaged(i), ref field1.RefSparseManaged(i), ref field2.RefSparseManaged(i), ref field3.RefSparseManaged(i), ref field4.RefSparseManaged(i), ref field5.RefSparseManaged(i), ref field6.RefSparseManaged(i), ref field7.RefSparseManaged(i), ref field8.RefSparseManaged(i), ref field9.RefSparseManaged(i), ref field10.RefSparseManaged(i), ref field11.RefSparseManaged(i), ref field12.RefSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSparseSharedManaged(i), ref field1.RefSparseSharedManaged(i), ref field2.RefSparseSharedManaged(i), ref field3.RefSparseSharedManaged(i), ref field4.RefSparseSharedManaged(i), ref field5.RefSparseSharedManaged(i), ref field6.RefSparseSharedManaged(i), ref field7.RefSparseSharedManaged(i), ref field8.RefSparseSharedManaged(i), ref field9.RefSparseSharedManaged(i), ref field10.RefSparseSharedManaged(i), ref field11.RefSparseSharedManaged(i), ref field12.RefSparseSharedManaged(i));
+        }
     }
 
     /// <summary>
@@ -80,15 +316,93 @@ public static void Each<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(I
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8); byte* pointer9 = (byte*)it.GetPointer<T9>(9); byte* pointer10 = (byte*)it.GetPointer<T10>(10); byte* pointer11 = (byte*)it.GetPointer<T11>(11); byte* pointer12 = (byte*)it.GetPointer<T12>(12);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8); int step9 = it.Step<T9>(9); int step10 = it.Step<T10>(10); int step11 = it.Step<T11>(11); int step12 = it.Step<T12>(12);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8); FieldData<T9> field9 = it.GetFieldData<T9>(9); FieldData<T10> field10 = it.GetFieldData<T10>(10); FieldData<T11> field11 = it.GetFieldData<T11>(11); FieldData<T12> field12 = it.GetFieldData<T12>(12);
+        IterationTechnique flags = it.GetIterationTechnique(13);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8], pointer9 = &pointer9[step9], pointer10 = &pointer10[step10], pointer11 = &pointer11[step11], pointer12 = &pointer12[step12])
-            callback(ref Managed.GetTypeRef<T0>(pointer0), ref Managed.GetTypeRef<T1>(pointer1), ref Managed.GetTypeRef<T2>(pointer2), ref Managed.GetTypeRef<T3>(pointer3), ref Managed.GetTypeRef<T4>(pointer4), ref Managed.GetTypeRef<T5>(pointer5), ref Managed.GetTypeRef<T6>(pointer6), ref Managed.GetTypeRef<T7>(pointer7), ref Managed.GetTypeRef<T8>(pointer8), ref Managed.GetTypeRef<T9>(pointer9), ref Managed.GetTypeRef<T10>(pointer10), ref Managed.GetTypeRef<T11>(pointer11), ref Managed.GetTypeRef<T12>(pointer12));
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>() || RuntimeHelpers.IsReferenceOrContainsReferences<T9>() || RuntimeHelpers.IsReferenceOrContainsReferences<T10>() || RuntimeHelpers.IsReferenceOrContainsReferences<T11>() || RuntimeHelpers.IsReferenceOrContainsReferences<T12>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefUnmanaged(i), ref field1.RefUnmanaged(i), ref field2.RefUnmanaged(i), ref field3.RefUnmanaged(i), ref field4.RefUnmanaged(i), ref field5.RefUnmanaged(i), ref field6.RefUnmanaged(i), ref field7.RefUnmanaged(i), ref field8.RefUnmanaged(i), ref field9.RefUnmanaged(i), ref field10.RefUnmanaged(i), ref field11.RefUnmanaged(i), ref field12.RefUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSharedUnmanaged(i), ref field1.RefSharedUnmanaged(i), ref field2.RefSharedUnmanaged(i), ref field3.RefSharedUnmanaged(i), ref field4.RefSharedUnmanaged(i), ref field5.RefSharedUnmanaged(i), ref field6.RefSharedUnmanaged(i), ref field7.RefSharedUnmanaged(i), ref field8.RefSharedUnmanaged(i), ref field9.RefSharedUnmanaged(i), ref field10.RefSharedUnmanaged(i), ref field11.RefSharedUnmanaged(i), ref field12.RefSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSparseUnmanaged(i), ref field1.RefSparseUnmanaged(i), ref field2.RefSparseUnmanaged(i), ref field3.RefSparseUnmanaged(i), ref field4.RefSparseUnmanaged(i), ref field5.RefSparseUnmanaged(i), ref field6.RefSparseUnmanaged(i), ref field7.RefSparseUnmanaged(i), ref field8.RefSparseUnmanaged(i), ref field9.RefSparseUnmanaged(i), ref field10.RefSparseUnmanaged(i), ref field11.RefSparseUnmanaged(i), ref field12.RefSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSparseSharedUnmanaged(i), ref field1.RefSparseSharedUnmanaged(i), ref field2.RefSparseSharedUnmanaged(i), ref field3.RefSparseSharedUnmanaged(i), ref field4.RefSparseSharedUnmanaged(i), ref field5.RefSparseSharedUnmanaged(i), ref field6.RefSparseSharedUnmanaged(i), ref field7.RefSparseSharedUnmanaged(i), ref field8.RefSparseSharedUnmanaged(i), ref field9.RefSparseSharedUnmanaged(i), ref field10.RefSparseSharedUnmanaged(i), ref field11.RefSparseSharedUnmanaged(i), ref field12.RefSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefManaged(i), ref field1.RefManaged(i), ref field2.RefManaged(i), ref field3.RefManaged(i), ref field4.RefManaged(i), ref field5.RefManaged(i), ref field6.RefManaged(i), ref field7.RefManaged(i), ref field8.RefManaged(i), ref field9.RefManaged(i), ref field10.RefManaged(i), ref field11.RefManaged(i), ref field12.RefManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSharedManaged(i), ref field1.RefSharedManaged(i), ref field2.RefSharedManaged(i), ref field3.RefSharedManaged(i), ref field4.RefSharedManaged(i), ref field5.RefSharedManaged(i), ref field6.RefSharedManaged(i), ref field7.RefSharedManaged(i), ref field8.RefSharedManaged(i), ref field9.RefSharedManaged(i), ref field10.RefSharedManaged(i), ref field11.RefSharedManaged(i), ref field12.RefSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSparseManaged(i), ref field1.RefSparseManaged(i), ref field2.RefSparseManaged(i), ref field3.RefSparseManaged(i), ref field4.RefSparseManaged(i), ref field5.RefSparseManaged(i), ref field6.RefSparseManaged(i), ref field7.RefSparseManaged(i), ref field8.RefSparseManaged(i), ref field9.RefSparseManaged(i), ref field10.RefSparseManaged(i), ref field11.RefSparseManaged(i), ref field12.RefSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSparseSharedManaged(i), ref field1.RefSparseSharedManaged(i), ref field2.RefSparseSharedManaged(i), ref field3.RefSparseSharedManaged(i), ref field4.RefSparseSharedManaged(i), ref field5.RefSparseSharedManaged(i), ref field6.RefSparseSharedManaged(i), ref field7.RefSparseSharedManaged(i), ref field8.RefSparseSharedManaged(i), ref field9.RefSparseSharedManaged(i), ref field10.RefSparseSharedManaged(i), ref field11.RefSparseSharedManaged(i), ref field12.RefSparseSharedManaged(i));
+        }
     }
 
     /// <summary>
@@ -101,15 +415,93 @@ public static void Each<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(I
     {
         int count = it.Handle->count; Ecs.Assert(it.Handle->count > 0, "No entities returned, use Iter() or Each() without the entity argument instead.");
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8); byte* pointer9 = (byte*)it.GetPointer<T9>(9); byte* pointer10 = (byte*)it.GetPointer<T10>(10); byte* pointer11 = (byte*)it.GetPointer<T11>(11); byte* pointer12 = (byte*)it.GetPointer<T12>(12);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8); int step9 = it.Step<T9>(9); int step10 = it.Step<T10>(10); int step11 = it.Step<T11>(11); int step12 = it.Step<T12>(12);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8); FieldData<T9> field9 = it.GetFieldData<T9>(9); FieldData<T10> field10 = it.GetFieldData<T10>(10); FieldData<T11> field11 = it.GetFieldData<T11>(11); FieldData<T12> field12 = it.GetFieldData<T12>(12);
+        IterationTechnique flags = it.GetIterationTechnique(13);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8], pointer9 = &pointer9[step9], pointer10 = &pointer10[step10], pointer11 = &pointer11[step11], pointer12 = &pointer12[step12])
-            callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref Managed.GetTypeRef<T0>(pointer0), ref Managed.GetTypeRef<T1>(pointer1), ref Managed.GetTypeRef<T2>(pointer2), ref Managed.GetTypeRef<T3>(pointer3), ref Managed.GetTypeRef<T4>(pointer4), ref Managed.GetTypeRef<T5>(pointer5), ref Managed.GetTypeRef<T6>(pointer6), ref Managed.GetTypeRef<T7>(pointer7), ref Managed.GetTypeRef<T8>(pointer8), ref Managed.GetTypeRef<T9>(pointer9), ref Managed.GetTypeRef<T10>(pointer10), ref Managed.GetTypeRef<T11>(pointer11), ref Managed.GetTypeRef<T12>(pointer12));
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>() || RuntimeHelpers.IsReferenceOrContainsReferences<T9>() || RuntimeHelpers.IsReferenceOrContainsReferences<T10>() || RuntimeHelpers.IsReferenceOrContainsReferences<T11>() || RuntimeHelpers.IsReferenceOrContainsReferences<T12>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefUnmanaged(i), ref field1.RefUnmanaged(i), ref field2.RefUnmanaged(i), ref field3.RefUnmanaged(i), ref field4.RefUnmanaged(i), ref field5.RefUnmanaged(i), ref field6.RefUnmanaged(i), ref field7.RefUnmanaged(i), ref field8.RefUnmanaged(i), ref field9.RefUnmanaged(i), ref field10.RefUnmanaged(i), ref field11.RefUnmanaged(i), ref field12.RefUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSharedUnmanaged(i), ref field1.RefSharedUnmanaged(i), ref field2.RefSharedUnmanaged(i), ref field3.RefSharedUnmanaged(i), ref field4.RefSharedUnmanaged(i), ref field5.RefSharedUnmanaged(i), ref field6.RefSharedUnmanaged(i), ref field7.RefSharedUnmanaged(i), ref field8.RefSharedUnmanaged(i), ref field9.RefSharedUnmanaged(i), ref field10.RefSharedUnmanaged(i), ref field11.RefSharedUnmanaged(i), ref field12.RefSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseUnmanaged(i), ref field1.RefSparseUnmanaged(i), ref field2.RefSparseUnmanaged(i), ref field3.RefSparseUnmanaged(i), ref field4.RefSparseUnmanaged(i), ref field5.RefSparseUnmanaged(i), ref field6.RefSparseUnmanaged(i), ref field7.RefSparseUnmanaged(i), ref field8.RefSparseUnmanaged(i), ref field9.RefSparseUnmanaged(i), ref field10.RefSparseUnmanaged(i), ref field11.RefSparseUnmanaged(i), ref field12.RefSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseSharedUnmanaged(i), ref field1.RefSparseSharedUnmanaged(i), ref field2.RefSparseSharedUnmanaged(i), ref field3.RefSparseSharedUnmanaged(i), ref field4.RefSparseSharedUnmanaged(i), ref field5.RefSparseSharedUnmanaged(i), ref field6.RefSparseSharedUnmanaged(i), ref field7.RefSparseSharedUnmanaged(i), ref field8.RefSparseSharedUnmanaged(i), ref field9.RefSparseSharedUnmanaged(i), ref field10.RefSparseSharedUnmanaged(i), ref field11.RefSparseSharedUnmanaged(i), ref field12.RefSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefManaged(i), ref field1.RefManaged(i), ref field2.RefManaged(i), ref field3.RefManaged(i), ref field4.RefManaged(i), ref field5.RefManaged(i), ref field6.RefManaged(i), ref field7.RefManaged(i), ref field8.RefManaged(i), ref field9.RefManaged(i), ref field10.RefManaged(i), ref field11.RefManaged(i), ref field12.RefManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSharedManaged(i), ref field1.RefSharedManaged(i), ref field2.RefSharedManaged(i), ref field3.RefSharedManaged(i), ref field4.RefSharedManaged(i), ref field5.RefSharedManaged(i), ref field6.RefSharedManaged(i), ref field7.RefSharedManaged(i), ref field8.RefSharedManaged(i), ref field9.RefSharedManaged(i), ref field10.RefSharedManaged(i), ref field11.RefSharedManaged(i), ref field12.RefSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseManaged(i), ref field1.RefSparseManaged(i), ref field2.RefSparseManaged(i), ref field3.RefSparseManaged(i), ref field4.RefSparseManaged(i), ref field5.RefSparseManaged(i), ref field6.RefSparseManaged(i), ref field7.RefSparseManaged(i), ref field8.RefSparseManaged(i), ref field9.RefSparseManaged(i), ref field10.RefSparseManaged(i), ref field11.RefSparseManaged(i), ref field12.RefSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseSharedManaged(i), ref field1.RefSparseSharedManaged(i), ref field2.RefSparseSharedManaged(i), ref field3.RefSparseSharedManaged(i), ref field4.RefSparseSharedManaged(i), ref field5.RefSparseSharedManaged(i), ref field6.RefSparseSharedManaged(i), ref field7.RefSparseSharedManaged(i), ref field8.RefSparseSharedManaged(i), ref field9.RefSparseSharedManaged(i), ref field10.RefSparseSharedManaged(i), ref field11.RefSparseSharedManaged(i), ref field12.RefSparseSharedManaged(i));
+        }
     }
 
     /// <summary>
@@ -122,15 +514,93 @@ public static void Each<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(I
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8); byte* pointer9 = (byte*)it.GetPointer<T9>(9); byte* pointer10 = (byte*)it.GetPointer<T10>(10); byte* pointer11 = (byte*)it.GetPointer<T11>(11); byte* pointer12 = (byte*)it.GetPointer<T12>(12);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8); int step9 = it.Step<T9>(9); int step10 = it.Step<T10>(10); int step11 = it.Step<T11>(11); int step12 = it.Step<T12>(12);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8); FieldData<T9> field9 = it.GetFieldData<T9>(9); FieldData<T10> field10 = it.GetFieldData<T10>(10); FieldData<T11> field11 = it.GetFieldData<T11>(11); FieldData<T12> field12 = it.GetFieldData<T12>(12);
+        IterationTechnique flags = it.GetIterationTechnique(13);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8], pointer9 = &pointer9[step9], pointer10 = &pointer10[step10], pointer11 = &pointer11[step11], pointer12 = &pointer12[step12])
-            callback(it, i, ref Managed.GetTypeRef<T0>(pointer0), ref Managed.GetTypeRef<T1>(pointer1), ref Managed.GetTypeRef<T2>(pointer2), ref Managed.GetTypeRef<T3>(pointer3), ref Managed.GetTypeRef<T4>(pointer4), ref Managed.GetTypeRef<T5>(pointer5), ref Managed.GetTypeRef<T6>(pointer6), ref Managed.GetTypeRef<T7>(pointer7), ref Managed.GetTypeRef<T8>(pointer8), ref Managed.GetTypeRef<T9>(pointer9), ref Managed.GetTypeRef<T10>(pointer10), ref Managed.GetTypeRef<T11>(pointer11), ref Managed.GetTypeRef<T12>(pointer12));
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>() || RuntimeHelpers.IsReferenceOrContainsReferences<T9>() || RuntimeHelpers.IsReferenceOrContainsReferences<T10>() || RuntimeHelpers.IsReferenceOrContainsReferences<T11>() || RuntimeHelpers.IsReferenceOrContainsReferences<T12>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefUnmanaged(i), ref field1.RefUnmanaged(i), ref field2.RefUnmanaged(i), ref field3.RefUnmanaged(i), ref field4.RefUnmanaged(i), ref field5.RefUnmanaged(i), ref field6.RefUnmanaged(i), ref field7.RefUnmanaged(i), ref field8.RefUnmanaged(i), ref field9.RefUnmanaged(i), ref field10.RefUnmanaged(i), ref field11.RefUnmanaged(i), ref field12.RefUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSharedUnmanaged(i), ref field1.RefSharedUnmanaged(i), ref field2.RefSharedUnmanaged(i), ref field3.RefSharedUnmanaged(i), ref field4.RefSharedUnmanaged(i), ref field5.RefSharedUnmanaged(i), ref field6.RefSharedUnmanaged(i), ref field7.RefSharedUnmanaged(i), ref field8.RefSharedUnmanaged(i), ref field9.RefSharedUnmanaged(i), ref field10.RefSharedUnmanaged(i), ref field11.RefSharedUnmanaged(i), ref field12.RefSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSparseUnmanaged(i), ref field1.RefSparseUnmanaged(i), ref field2.RefSparseUnmanaged(i), ref field3.RefSparseUnmanaged(i), ref field4.RefSparseUnmanaged(i), ref field5.RefSparseUnmanaged(i), ref field6.RefSparseUnmanaged(i), ref field7.RefSparseUnmanaged(i), ref field8.RefSparseUnmanaged(i), ref field9.RefSparseUnmanaged(i), ref field10.RefSparseUnmanaged(i), ref field11.RefSparseUnmanaged(i), ref field12.RefSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSparseSharedUnmanaged(i), ref field1.RefSparseSharedUnmanaged(i), ref field2.RefSparseSharedUnmanaged(i), ref field3.RefSparseSharedUnmanaged(i), ref field4.RefSparseSharedUnmanaged(i), ref field5.RefSparseSharedUnmanaged(i), ref field6.RefSparseSharedUnmanaged(i), ref field7.RefSparseSharedUnmanaged(i), ref field8.RefSparseSharedUnmanaged(i), ref field9.RefSparseSharedUnmanaged(i), ref field10.RefSparseSharedUnmanaged(i), ref field11.RefSparseSharedUnmanaged(i), ref field12.RefSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefManaged(i), ref field1.RefManaged(i), ref field2.RefManaged(i), ref field3.RefManaged(i), ref field4.RefManaged(i), ref field5.RefManaged(i), ref field6.RefManaged(i), ref field7.RefManaged(i), ref field8.RefManaged(i), ref field9.RefManaged(i), ref field10.RefManaged(i), ref field11.RefManaged(i), ref field12.RefManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSharedManaged(i), ref field1.RefSharedManaged(i), ref field2.RefSharedManaged(i), ref field3.RefSharedManaged(i), ref field4.RefSharedManaged(i), ref field5.RefSharedManaged(i), ref field6.RefSharedManaged(i), ref field7.RefSharedManaged(i), ref field8.RefSharedManaged(i), ref field9.RefSharedManaged(i), ref field10.RefSharedManaged(i), ref field11.RefSharedManaged(i), ref field12.RefSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSparseManaged(i), ref field1.RefSparseManaged(i), ref field2.RefSparseManaged(i), ref field3.RefSparseManaged(i), ref field4.RefSparseManaged(i), ref field5.RefSparseManaged(i), ref field6.RefSparseManaged(i), ref field7.RefSparseManaged(i), ref field8.RefSparseManaged(i), ref field9.RefSparseManaged(i), ref field10.RefSparseManaged(i), ref field11.RefSparseManaged(i), ref field12.RefSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSparseSharedManaged(i), ref field1.RefSparseSharedManaged(i), ref field2.RefSparseSharedManaged(i), ref field3.RefSparseSharedManaged(i), ref field4.RefSparseSharedManaged(i), ref field5.RefSparseSharedManaged(i), ref field6.RefSparseSharedManaged(i), ref field7.RefSparseSharedManaged(i), ref field8.RefSparseSharedManaged(i), ref field9.RefSparseSharedManaged(i), ref field10.RefSparseSharedManaged(i), ref field11.RefSparseSharedManaged(i), ref field12.RefSparseSharedManaged(i));
+        }
     }
 
     /// <summary>
@@ -143,15 +613,93 @@ public static void Each<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(I
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8); byte* pointer9 = (byte*)it.GetPointer<T9>(9); byte* pointer10 = (byte*)it.GetPointer<T10>(10); byte* pointer11 = (byte*)it.GetPointer<T11>(11); byte* pointer12 = (byte*)it.GetPointer<T12>(12);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8); int step9 = it.Step<T9>(9); int step10 = it.Step<T10>(10); int step11 = it.Step<T11>(11); int step12 = it.Step<T12>(12);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8); FieldData<T9> field9 = it.GetFieldData<T9>(9); FieldData<T10> field10 = it.GetFieldData<T10>(10); FieldData<T11> field11 = it.GetFieldData<T11>(11); FieldData<T12> field12 = it.GetFieldData<T12>(12);
+        IterationTechnique flags = it.GetIterationTechnique(13);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8], pointer9 = &pointer9[step9], pointer10 = &pointer10[step10], pointer11 = &pointer11[step11], pointer12 = &pointer12[step12])
-            callback((T0*)pointer0, (T1*)pointer1, (T2*)pointer2, (T3*)pointer3, (T4*)pointer4, (T5*)pointer5, (T6*)pointer6, (T7*)pointer7, (T8*)pointer8, (T9*)pointer9, (T10*)pointer10, (T11*)pointer11, (T12*)pointer12);
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>() || RuntimeHelpers.IsReferenceOrContainsReferences<T9>() || RuntimeHelpers.IsReferenceOrContainsReferences<T10>() || RuntimeHelpers.IsReferenceOrContainsReferences<T11>() || RuntimeHelpers.IsReferenceOrContainsReferences<T12>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerUnmanaged(i), field1.PointerUnmanaged(i), field2.PointerUnmanaged(i), field3.PointerUnmanaged(i), field4.PointerUnmanaged(i), field5.PointerUnmanaged(i), field6.PointerUnmanaged(i), field7.PointerUnmanaged(i), field8.PointerUnmanaged(i), field9.PointerUnmanaged(i), field10.PointerUnmanaged(i), field11.PointerUnmanaged(i), field12.PointerUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSharedUnmanaged(i), field1.PointerSharedUnmanaged(i), field2.PointerSharedUnmanaged(i), field3.PointerSharedUnmanaged(i), field4.PointerSharedUnmanaged(i), field5.PointerSharedUnmanaged(i), field6.PointerSharedUnmanaged(i), field7.PointerSharedUnmanaged(i), field8.PointerSharedUnmanaged(i), field9.PointerSharedUnmanaged(i), field10.PointerSharedUnmanaged(i), field11.PointerSharedUnmanaged(i), field12.PointerSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSparseUnmanaged(i), field1.PointerSparseUnmanaged(i), field2.PointerSparseUnmanaged(i), field3.PointerSparseUnmanaged(i), field4.PointerSparseUnmanaged(i), field5.PointerSparseUnmanaged(i), field6.PointerSparseUnmanaged(i), field7.PointerSparseUnmanaged(i), field8.PointerSparseUnmanaged(i), field9.PointerSparseUnmanaged(i), field10.PointerSparseUnmanaged(i), field11.PointerSparseUnmanaged(i), field12.PointerSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSparseSharedUnmanaged(i), field1.PointerSparseSharedUnmanaged(i), field2.PointerSparseSharedUnmanaged(i), field3.PointerSparseSharedUnmanaged(i), field4.PointerSparseSharedUnmanaged(i), field5.PointerSparseSharedUnmanaged(i), field6.PointerSparseSharedUnmanaged(i), field7.PointerSparseSharedUnmanaged(i), field8.PointerSparseSharedUnmanaged(i), field9.PointerSparseSharedUnmanaged(i), field10.PointerSparseSharedUnmanaged(i), field11.PointerSparseSharedUnmanaged(i), field12.PointerSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerManaged(i), field1.PointerManaged(i), field2.PointerManaged(i), field3.PointerManaged(i), field4.PointerManaged(i), field5.PointerManaged(i), field6.PointerManaged(i), field7.PointerManaged(i), field8.PointerManaged(i), field9.PointerManaged(i), field10.PointerManaged(i), field11.PointerManaged(i), field12.PointerManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSharedManaged(i), field1.PointerSharedManaged(i), field2.PointerSharedManaged(i), field3.PointerSharedManaged(i), field4.PointerSharedManaged(i), field5.PointerSharedManaged(i), field6.PointerSharedManaged(i), field7.PointerSharedManaged(i), field8.PointerSharedManaged(i), field9.PointerSharedManaged(i), field10.PointerSharedManaged(i), field11.PointerSharedManaged(i), field12.PointerSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSparseManaged(i), field1.PointerSparseManaged(i), field2.PointerSparseManaged(i), field3.PointerSparseManaged(i), field4.PointerSparseManaged(i), field5.PointerSparseManaged(i), field6.PointerSparseManaged(i), field7.PointerSparseManaged(i), field8.PointerSparseManaged(i), field9.PointerSparseManaged(i), field10.PointerSparseManaged(i), field11.PointerSparseManaged(i), field12.PointerSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSparseSharedManaged(i), field1.PointerSparseSharedManaged(i), field2.PointerSparseSharedManaged(i), field3.PointerSparseSharedManaged(i), field4.PointerSparseSharedManaged(i), field5.PointerSparseSharedManaged(i), field6.PointerSparseSharedManaged(i), field7.PointerSparseSharedManaged(i), field8.PointerSparseSharedManaged(i), field9.PointerSparseSharedManaged(i), field10.PointerSparseSharedManaged(i), field11.PointerSparseSharedManaged(i), field12.PointerSparseSharedManaged(i));
+        }
     }
 
     /// <summary>
@@ -164,15 +712,93 @@ public static void Each<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(I
     {
         int count = it.Handle->count; Ecs.Assert(it.Handle->count > 0, "No entities returned, use Iter() or Each() without the entity argument instead.");
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8); byte* pointer9 = (byte*)it.GetPointer<T9>(9); byte* pointer10 = (byte*)it.GetPointer<T10>(10); byte* pointer11 = (byte*)it.GetPointer<T11>(11); byte* pointer12 = (byte*)it.GetPointer<T12>(12);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8); int step9 = it.Step<T9>(9); int step10 = it.Step<T10>(10); int step11 = it.Step<T11>(11); int step12 = it.Step<T12>(12);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8); FieldData<T9> field9 = it.GetFieldData<T9>(9); FieldData<T10> field10 = it.GetFieldData<T10>(10); FieldData<T11> field11 = it.GetFieldData<T11>(11); FieldData<T12> field12 = it.GetFieldData<T12>(12);
+        IterationTechnique flags = it.GetIterationTechnique(13);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8], pointer9 = &pointer9[step9], pointer10 = &pointer10[step10], pointer11 = &pointer11[step11], pointer12 = &pointer12[step12])
-            callback(new Entity(it.Handle->world, it.Handle->entities[i]), (T0*)pointer0, (T1*)pointer1, (T2*)pointer2, (T3*)pointer3, (T4*)pointer4, (T5*)pointer5, (T6*)pointer6, (T7*)pointer7, (T8*)pointer8, (T9*)pointer9, (T10*)pointer10, (T11*)pointer11, (T12*)pointer12);
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>() || RuntimeHelpers.IsReferenceOrContainsReferences<T9>() || RuntimeHelpers.IsReferenceOrContainsReferences<T10>() || RuntimeHelpers.IsReferenceOrContainsReferences<T11>() || RuntimeHelpers.IsReferenceOrContainsReferences<T12>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerUnmanaged(i), field1.PointerUnmanaged(i), field2.PointerUnmanaged(i), field3.PointerUnmanaged(i), field4.PointerUnmanaged(i), field5.PointerUnmanaged(i), field6.PointerUnmanaged(i), field7.PointerUnmanaged(i), field8.PointerUnmanaged(i), field9.PointerUnmanaged(i), field10.PointerUnmanaged(i), field11.PointerUnmanaged(i), field12.PointerUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSharedUnmanaged(i), field1.PointerSharedUnmanaged(i), field2.PointerSharedUnmanaged(i), field3.PointerSharedUnmanaged(i), field4.PointerSharedUnmanaged(i), field5.PointerSharedUnmanaged(i), field6.PointerSharedUnmanaged(i), field7.PointerSharedUnmanaged(i), field8.PointerSharedUnmanaged(i), field9.PointerSharedUnmanaged(i), field10.PointerSharedUnmanaged(i), field11.PointerSharedUnmanaged(i), field12.PointerSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseUnmanaged(i), field1.PointerSparseUnmanaged(i), field2.PointerSparseUnmanaged(i), field3.PointerSparseUnmanaged(i), field4.PointerSparseUnmanaged(i), field5.PointerSparseUnmanaged(i), field6.PointerSparseUnmanaged(i), field7.PointerSparseUnmanaged(i), field8.PointerSparseUnmanaged(i), field9.PointerSparseUnmanaged(i), field10.PointerSparseUnmanaged(i), field11.PointerSparseUnmanaged(i), field12.PointerSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseSharedUnmanaged(i), field1.PointerSparseSharedUnmanaged(i), field2.PointerSparseSharedUnmanaged(i), field3.PointerSparseSharedUnmanaged(i), field4.PointerSparseSharedUnmanaged(i), field5.PointerSparseSharedUnmanaged(i), field6.PointerSparseSharedUnmanaged(i), field7.PointerSparseSharedUnmanaged(i), field8.PointerSparseSharedUnmanaged(i), field9.PointerSparseSharedUnmanaged(i), field10.PointerSparseSharedUnmanaged(i), field11.PointerSparseSharedUnmanaged(i), field12.PointerSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerManaged(i), field1.PointerManaged(i), field2.PointerManaged(i), field3.PointerManaged(i), field4.PointerManaged(i), field5.PointerManaged(i), field6.PointerManaged(i), field7.PointerManaged(i), field8.PointerManaged(i), field9.PointerManaged(i), field10.PointerManaged(i), field11.PointerManaged(i), field12.PointerManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSharedManaged(i), field1.PointerSharedManaged(i), field2.PointerSharedManaged(i), field3.PointerSharedManaged(i), field4.PointerSharedManaged(i), field5.PointerSharedManaged(i), field6.PointerSharedManaged(i), field7.PointerSharedManaged(i), field8.PointerSharedManaged(i), field9.PointerSharedManaged(i), field10.PointerSharedManaged(i), field11.PointerSharedManaged(i), field12.PointerSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseManaged(i), field1.PointerSparseManaged(i), field2.PointerSparseManaged(i), field3.PointerSparseManaged(i), field4.PointerSparseManaged(i), field5.PointerSparseManaged(i), field6.PointerSparseManaged(i), field7.PointerSparseManaged(i), field8.PointerSparseManaged(i), field9.PointerSparseManaged(i), field10.PointerSparseManaged(i), field11.PointerSparseManaged(i), field12.PointerSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseSharedManaged(i), field1.PointerSparseSharedManaged(i), field2.PointerSparseSharedManaged(i), field3.PointerSparseSharedManaged(i), field4.PointerSparseSharedManaged(i), field5.PointerSparseSharedManaged(i), field6.PointerSparseSharedManaged(i), field7.PointerSparseSharedManaged(i), field8.PointerSparseSharedManaged(i), field9.PointerSparseSharedManaged(i), field10.PointerSparseSharedManaged(i), field11.PointerSparseSharedManaged(i), field12.PointerSparseSharedManaged(i));
+        }
     }
 
     /// <summary>
@@ -185,15 +811,93 @@ public static void Each<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(I
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8); byte* pointer9 = (byte*)it.GetPointer<T9>(9); byte* pointer10 = (byte*)it.GetPointer<T10>(10); byte* pointer11 = (byte*)it.GetPointer<T11>(11); byte* pointer12 = (byte*)it.GetPointer<T12>(12);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8); int step9 = it.Step<T9>(9); int step10 = it.Step<T10>(10); int step11 = it.Step<T11>(11); int step12 = it.Step<T12>(12);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8); FieldData<T9> field9 = it.GetFieldData<T9>(9); FieldData<T10> field10 = it.GetFieldData<T10>(10); FieldData<T11> field11 = it.GetFieldData<T11>(11); FieldData<T12> field12 = it.GetFieldData<T12>(12);
+        IterationTechnique flags = it.GetIterationTechnique(13);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8], pointer9 = &pointer9[step9], pointer10 = &pointer10[step10], pointer11 = &pointer11[step11], pointer12 = &pointer12[step12])
-            callback(it, i, (T0*)pointer0, (T1*)pointer1, (T2*)pointer2, (T3*)pointer3, (T4*)pointer4, (T5*)pointer5, (T6*)pointer6, (T7*)pointer7, (T8*)pointer8, (T9*)pointer9, (T10*)pointer10, (T11*)pointer11, (T12*)pointer12);
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>() || RuntimeHelpers.IsReferenceOrContainsReferences<T9>() || RuntimeHelpers.IsReferenceOrContainsReferences<T10>() || RuntimeHelpers.IsReferenceOrContainsReferences<T11>() || RuntimeHelpers.IsReferenceOrContainsReferences<T12>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerUnmanaged(i), field1.PointerUnmanaged(i), field2.PointerUnmanaged(i), field3.PointerUnmanaged(i), field4.PointerUnmanaged(i), field5.PointerUnmanaged(i), field6.PointerUnmanaged(i), field7.PointerUnmanaged(i), field8.PointerUnmanaged(i), field9.PointerUnmanaged(i), field10.PointerUnmanaged(i), field11.PointerUnmanaged(i), field12.PointerUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSharedUnmanaged(i), field1.PointerSharedUnmanaged(i), field2.PointerSharedUnmanaged(i), field3.PointerSharedUnmanaged(i), field4.PointerSharedUnmanaged(i), field5.PointerSharedUnmanaged(i), field6.PointerSharedUnmanaged(i), field7.PointerSharedUnmanaged(i), field8.PointerSharedUnmanaged(i), field9.PointerSharedUnmanaged(i), field10.PointerSharedUnmanaged(i), field11.PointerSharedUnmanaged(i), field12.PointerSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSparseUnmanaged(i), field1.PointerSparseUnmanaged(i), field2.PointerSparseUnmanaged(i), field3.PointerSparseUnmanaged(i), field4.PointerSparseUnmanaged(i), field5.PointerSparseUnmanaged(i), field6.PointerSparseUnmanaged(i), field7.PointerSparseUnmanaged(i), field8.PointerSparseUnmanaged(i), field9.PointerSparseUnmanaged(i), field10.PointerSparseUnmanaged(i), field11.PointerSparseUnmanaged(i), field12.PointerSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSparseSharedUnmanaged(i), field1.PointerSparseSharedUnmanaged(i), field2.PointerSparseSharedUnmanaged(i), field3.PointerSparseSharedUnmanaged(i), field4.PointerSparseSharedUnmanaged(i), field5.PointerSparseSharedUnmanaged(i), field6.PointerSparseSharedUnmanaged(i), field7.PointerSparseSharedUnmanaged(i), field8.PointerSparseSharedUnmanaged(i), field9.PointerSparseSharedUnmanaged(i), field10.PointerSparseSharedUnmanaged(i), field11.PointerSparseSharedUnmanaged(i), field12.PointerSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerManaged(i), field1.PointerManaged(i), field2.PointerManaged(i), field3.PointerManaged(i), field4.PointerManaged(i), field5.PointerManaged(i), field6.PointerManaged(i), field7.PointerManaged(i), field8.PointerManaged(i), field9.PointerManaged(i), field10.PointerManaged(i), field11.PointerManaged(i), field12.PointerManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSharedManaged(i), field1.PointerSharedManaged(i), field2.PointerSharedManaged(i), field3.PointerSharedManaged(i), field4.PointerSharedManaged(i), field5.PointerSharedManaged(i), field6.PointerSharedManaged(i), field7.PointerSharedManaged(i), field8.PointerSharedManaged(i), field9.PointerSharedManaged(i), field10.PointerSharedManaged(i), field11.PointerSharedManaged(i), field12.PointerSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSparseManaged(i), field1.PointerSparseManaged(i), field2.PointerSparseManaged(i), field3.PointerSparseManaged(i), field4.PointerSparseManaged(i), field5.PointerSparseManaged(i), field6.PointerSparseManaged(i), field7.PointerSparseManaged(i), field8.PointerSparseManaged(i), field9.PointerSparseManaged(i), field10.PointerSparseManaged(i), field11.PointerSparseManaged(i), field12.PointerSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSparseSharedManaged(i), field1.PointerSparseSharedManaged(i), field2.PointerSparseSharedManaged(i), field3.PointerSparseSharedManaged(i), field4.PointerSparseSharedManaged(i), field5.PointerSparseSharedManaged(i), field6.PointerSparseSharedManaged(i), field7.PointerSparseSharedManaged(i), field8.PointerSparseSharedManaged(i), field9.PointerSparseSharedManaged(i), field10.PointerSparseSharedManaged(i), field11.PointerSparseSharedManaged(i), field12.PointerSparseSharedManaged(i));
+        }
     }
 
     /// <summary>
@@ -206,15 +910,93 @@ public static void Each<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(I
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8); byte* pointer9 = (byte*)it.GetPointer<T9>(9); byte* pointer10 = (byte*)it.GetPointer<T10>(10); byte* pointer11 = (byte*)it.GetPointer<T11>(11); byte* pointer12 = (byte*)it.GetPointer<T12>(12);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8); int step9 = it.Step<T9>(9); int step10 = it.Step<T10>(10); int step11 = it.Step<T11>(11); int step12 = it.Step<T12>(12);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8); FieldData<T9> field9 = it.GetFieldData<T9>(9); FieldData<T10> field10 = it.GetFieldData<T10>(10); FieldData<T11> field11 = it.GetFieldData<T11>(11); FieldData<T12> field12 = it.GetFieldData<T12>(12);
+        IterationTechnique flags = it.GetIterationTechnique(13);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8], pointer9 = &pointer9[step9], pointer10 = &pointer10[step10], pointer11 = &pointer11[step11], pointer12 = &pointer12[step12])
-            callback((T0*)pointer0, (T1*)pointer1, (T2*)pointer2, (T3*)pointer3, (T4*)pointer4, (T5*)pointer5, (T6*)pointer6, (T7*)pointer7, (T8*)pointer8, (T9*)pointer9, (T10*)pointer10, (T11*)pointer11, (T12*)pointer12);
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>() || RuntimeHelpers.IsReferenceOrContainsReferences<T9>() || RuntimeHelpers.IsReferenceOrContainsReferences<T10>() || RuntimeHelpers.IsReferenceOrContainsReferences<T11>() || RuntimeHelpers.IsReferenceOrContainsReferences<T12>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerUnmanaged(i), field1.PointerUnmanaged(i), field2.PointerUnmanaged(i), field3.PointerUnmanaged(i), field4.PointerUnmanaged(i), field5.PointerUnmanaged(i), field6.PointerUnmanaged(i), field7.PointerUnmanaged(i), field8.PointerUnmanaged(i), field9.PointerUnmanaged(i), field10.PointerUnmanaged(i), field11.PointerUnmanaged(i), field12.PointerUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSharedUnmanaged(i), field1.PointerSharedUnmanaged(i), field2.PointerSharedUnmanaged(i), field3.PointerSharedUnmanaged(i), field4.PointerSharedUnmanaged(i), field5.PointerSharedUnmanaged(i), field6.PointerSharedUnmanaged(i), field7.PointerSharedUnmanaged(i), field8.PointerSharedUnmanaged(i), field9.PointerSharedUnmanaged(i), field10.PointerSharedUnmanaged(i), field11.PointerSharedUnmanaged(i), field12.PointerSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSparseUnmanaged(i), field1.PointerSparseUnmanaged(i), field2.PointerSparseUnmanaged(i), field3.PointerSparseUnmanaged(i), field4.PointerSparseUnmanaged(i), field5.PointerSparseUnmanaged(i), field6.PointerSparseUnmanaged(i), field7.PointerSparseUnmanaged(i), field8.PointerSparseUnmanaged(i), field9.PointerSparseUnmanaged(i), field10.PointerSparseUnmanaged(i), field11.PointerSparseUnmanaged(i), field12.PointerSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSparseSharedUnmanaged(i), field1.PointerSparseSharedUnmanaged(i), field2.PointerSparseSharedUnmanaged(i), field3.PointerSparseSharedUnmanaged(i), field4.PointerSparseSharedUnmanaged(i), field5.PointerSparseSharedUnmanaged(i), field6.PointerSparseSharedUnmanaged(i), field7.PointerSparseSharedUnmanaged(i), field8.PointerSparseSharedUnmanaged(i), field9.PointerSparseSharedUnmanaged(i), field10.PointerSparseSharedUnmanaged(i), field11.PointerSparseSharedUnmanaged(i), field12.PointerSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerManaged(i), field1.PointerManaged(i), field2.PointerManaged(i), field3.PointerManaged(i), field4.PointerManaged(i), field5.PointerManaged(i), field6.PointerManaged(i), field7.PointerManaged(i), field8.PointerManaged(i), field9.PointerManaged(i), field10.PointerManaged(i), field11.PointerManaged(i), field12.PointerManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSharedManaged(i), field1.PointerSharedManaged(i), field2.PointerSharedManaged(i), field3.PointerSharedManaged(i), field4.PointerSharedManaged(i), field5.PointerSharedManaged(i), field6.PointerSharedManaged(i), field7.PointerSharedManaged(i), field8.PointerSharedManaged(i), field9.PointerSharedManaged(i), field10.PointerSharedManaged(i), field11.PointerSharedManaged(i), field12.PointerSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSparseManaged(i), field1.PointerSparseManaged(i), field2.PointerSparseManaged(i), field3.PointerSparseManaged(i), field4.PointerSparseManaged(i), field5.PointerSparseManaged(i), field6.PointerSparseManaged(i), field7.PointerSparseManaged(i), field8.PointerSparseManaged(i), field9.PointerSparseManaged(i), field10.PointerSparseManaged(i), field11.PointerSparseManaged(i), field12.PointerSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSparseSharedManaged(i), field1.PointerSparseSharedManaged(i), field2.PointerSparseSharedManaged(i), field3.PointerSparseSharedManaged(i), field4.PointerSparseSharedManaged(i), field5.PointerSparseSharedManaged(i), field6.PointerSparseSharedManaged(i), field7.PointerSparseSharedManaged(i), field8.PointerSparseSharedManaged(i), field9.PointerSparseSharedManaged(i), field10.PointerSparseSharedManaged(i), field11.PointerSparseSharedManaged(i), field12.PointerSparseSharedManaged(i));
+        }
     }
 
     /// <summary>
@@ -227,15 +1009,93 @@ public static void Each<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(I
     {
         int count = it.Handle->count; Ecs.Assert(it.Handle->count > 0, "No entities returned, use Iter() or Each() without the entity argument instead.");
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8); byte* pointer9 = (byte*)it.GetPointer<T9>(9); byte* pointer10 = (byte*)it.GetPointer<T10>(10); byte* pointer11 = (byte*)it.GetPointer<T11>(11); byte* pointer12 = (byte*)it.GetPointer<T12>(12);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8); int step9 = it.Step<T9>(9); int step10 = it.Step<T10>(10); int step11 = it.Step<T11>(11); int step12 = it.Step<T12>(12);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8); FieldData<T9> field9 = it.GetFieldData<T9>(9); FieldData<T10> field10 = it.GetFieldData<T10>(10); FieldData<T11> field11 = it.GetFieldData<T11>(11); FieldData<T12> field12 = it.GetFieldData<T12>(12);
+        IterationTechnique flags = it.GetIterationTechnique(13);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8], pointer9 = &pointer9[step9], pointer10 = &pointer10[step10], pointer11 = &pointer11[step11], pointer12 = &pointer12[step12])
-            callback(new Entity(it.Handle->world, it.Handle->entities[i]), (T0*)pointer0, (T1*)pointer1, (T2*)pointer2, (T3*)pointer3, (T4*)pointer4, (T5*)pointer5, (T6*)pointer6, (T7*)pointer7, (T8*)pointer8, (T9*)pointer9, (T10*)pointer10, (T11*)pointer11, (T12*)pointer12);
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>() || RuntimeHelpers.IsReferenceOrContainsReferences<T9>() || RuntimeHelpers.IsReferenceOrContainsReferences<T10>() || RuntimeHelpers.IsReferenceOrContainsReferences<T11>() || RuntimeHelpers.IsReferenceOrContainsReferences<T12>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerUnmanaged(i), field1.PointerUnmanaged(i), field2.PointerUnmanaged(i), field3.PointerUnmanaged(i), field4.PointerUnmanaged(i), field5.PointerUnmanaged(i), field6.PointerUnmanaged(i), field7.PointerUnmanaged(i), field8.PointerUnmanaged(i), field9.PointerUnmanaged(i), field10.PointerUnmanaged(i), field11.PointerUnmanaged(i), field12.PointerUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSharedUnmanaged(i), field1.PointerSharedUnmanaged(i), field2.PointerSharedUnmanaged(i), field3.PointerSharedUnmanaged(i), field4.PointerSharedUnmanaged(i), field5.PointerSharedUnmanaged(i), field6.PointerSharedUnmanaged(i), field7.PointerSharedUnmanaged(i), field8.PointerSharedUnmanaged(i), field9.PointerSharedUnmanaged(i), field10.PointerSharedUnmanaged(i), field11.PointerSharedUnmanaged(i), field12.PointerSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseUnmanaged(i), field1.PointerSparseUnmanaged(i), field2.PointerSparseUnmanaged(i), field3.PointerSparseUnmanaged(i), field4.PointerSparseUnmanaged(i), field5.PointerSparseUnmanaged(i), field6.PointerSparseUnmanaged(i), field7.PointerSparseUnmanaged(i), field8.PointerSparseUnmanaged(i), field9.PointerSparseUnmanaged(i), field10.PointerSparseUnmanaged(i), field11.PointerSparseUnmanaged(i), field12.PointerSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseSharedUnmanaged(i), field1.PointerSparseSharedUnmanaged(i), field2.PointerSparseSharedUnmanaged(i), field3.PointerSparseSharedUnmanaged(i), field4.PointerSparseSharedUnmanaged(i), field5.PointerSparseSharedUnmanaged(i), field6.PointerSparseSharedUnmanaged(i), field7.PointerSparseSharedUnmanaged(i), field8.PointerSparseSharedUnmanaged(i), field9.PointerSparseSharedUnmanaged(i), field10.PointerSparseSharedUnmanaged(i), field11.PointerSparseSharedUnmanaged(i), field12.PointerSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerManaged(i), field1.PointerManaged(i), field2.PointerManaged(i), field3.PointerManaged(i), field4.PointerManaged(i), field5.PointerManaged(i), field6.PointerManaged(i), field7.PointerManaged(i), field8.PointerManaged(i), field9.PointerManaged(i), field10.PointerManaged(i), field11.PointerManaged(i), field12.PointerManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSharedManaged(i), field1.PointerSharedManaged(i), field2.PointerSharedManaged(i), field3.PointerSharedManaged(i), field4.PointerSharedManaged(i), field5.PointerSharedManaged(i), field6.PointerSharedManaged(i), field7.PointerSharedManaged(i), field8.PointerSharedManaged(i), field9.PointerSharedManaged(i), field10.PointerSharedManaged(i), field11.PointerSharedManaged(i), field12.PointerSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseManaged(i), field1.PointerSparseManaged(i), field2.PointerSparseManaged(i), field3.PointerSparseManaged(i), field4.PointerSparseManaged(i), field5.PointerSparseManaged(i), field6.PointerSparseManaged(i), field7.PointerSparseManaged(i), field8.PointerSparseManaged(i), field9.PointerSparseManaged(i), field10.PointerSparseManaged(i), field11.PointerSparseManaged(i), field12.PointerSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseSharedManaged(i), field1.PointerSparseSharedManaged(i), field2.PointerSparseSharedManaged(i), field3.PointerSparseSharedManaged(i), field4.PointerSparseSharedManaged(i), field5.PointerSparseSharedManaged(i), field6.PointerSparseSharedManaged(i), field7.PointerSparseSharedManaged(i), field8.PointerSparseSharedManaged(i), field9.PointerSparseSharedManaged(i), field10.PointerSparseSharedManaged(i), field11.PointerSparseSharedManaged(i), field12.PointerSparseSharedManaged(i));
+        }
     }
 
     /// <summary>
@@ -248,14 +1108,92 @@ public static void Each<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(I
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8); byte* pointer9 = (byte*)it.GetPointer<T9>(9); byte* pointer10 = (byte*)it.GetPointer<T10>(10); byte* pointer11 = (byte*)it.GetPointer<T11>(11); byte* pointer12 = (byte*)it.GetPointer<T12>(12);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8); int step9 = it.Step<T9>(9); int step10 = it.Step<T10>(10); int step11 = it.Step<T11>(11); int step12 = it.Step<T12>(12);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8); FieldData<T9> field9 = it.GetFieldData<T9>(9); FieldData<T10> field10 = it.GetFieldData<T10>(10); FieldData<T11> field11 = it.GetFieldData<T11>(11); FieldData<T12> field12 = it.GetFieldData<T12>(12);
+        IterationTechnique flags = it.GetIterationTechnique(13);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8], pointer9 = &pointer9[step9], pointer10 = &pointer10[step10], pointer11 = &pointer11[step11], pointer12 = &pointer12[step12])
-            callback(it, i, (T0*)pointer0, (T1*)pointer1, (T2*)pointer2, (T3*)pointer3, (T4*)pointer4, (T5*)pointer5, (T6*)pointer6, (T7*)pointer7, (T8*)pointer8, (T9*)pointer9, (T10*)pointer10, (T11*)pointer11, (T12*)pointer12);
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>() || RuntimeHelpers.IsReferenceOrContainsReferences<T9>() || RuntimeHelpers.IsReferenceOrContainsReferences<T10>() || RuntimeHelpers.IsReferenceOrContainsReferences<T11>() || RuntimeHelpers.IsReferenceOrContainsReferences<T12>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerUnmanaged(i), field1.PointerUnmanaged(i), field2.PointerUnmanaged(i), field3.PointerUnmanaged(i), field4.PointerUnmanaged(i), field5.PointerUnmanaged(i), field6.PointerUnmanaged(i), field7.PointerUnmanaged(i), field8.PointerUnmanaged(i), field9.PointerUnmanaged(i), field10.PointerUnmanaged(i), field11.PointerUnmanaged(i), field12.PointerUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSharedUnmanaged(i), field1.PointerSharedUnmanaged(i), field2.PointerSharedUnmanaged(i), field3.PointerSharedUnmanaged(i), field4.PointerSharedUnmanaged(i), field5.PointerSharedUnmanaged(i), field6.PointerSharedUnmanaged(i), field7.PointerSharedUnmanaged(i), field8.PointerSharedUnmanaged(i), field9.PointerSharedUnmanaged(i), field10.PointerSharedUnmanaged(i), field11.PointerSharedUnmanaged(i), field12.PointerSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSparseUnmanaged(i), field1.PointerSparseUnmanaged(i), field2.PointerSparseUnmanaged(i), field3.PointerSparseUnmanaged(i), field4.PointerSparseUnmanaged(i), field5.PointerSparseUnmanaged(i), field6.PointerSparseUnmanaged(i), field7.PointerSparseUnmanaged(i), field8.PointerSparseUnmanaged(i), field9.PointerSparseUnmanaged(i), field10.PointerSparseUnmanaged(i), field11.PointerSparseUnmanaged(i), field12.PointerSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSparseSharedUnmanaged(i), field1.PointerSparseSharedUnmanaged(i), field2.PointerSparseSharedUnmanaged(i), field3.PointerSparseSharedUnmanaged(i), field4.PointerSparseSharedUnmanaged(i), field5.PointerSparseSharedUnmanaged(i), field6.PointerSparseSharedUnmanaged(i), field7.PointerSparseSharedUnmanaged(i), field8.PointerSparseSharedUnmanaged(i), field9.PointerSparseSharedUnmanaged(i), field10.PointerSparseSharedUnmanaged(i), field11.PointerSparseSharedUnmanaged(i), field12.PointerSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerManaged(i), field1.PointerManaged(i), field2.PointerManaged(i), field3.PointerManaged(i), field4.PointerManaged(i), field5.PointerManaged(i), field6.PointerManaged(i), field7.PointerManaged(i), field8.PointerManaged(i), field9.PointerManaged(i), field10.PointerManaged(i), field11.PointerManaged(i), field12.PointerManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSharedManaged(i), field1.PointerSharedManaged(i), field2.PointerSharedManaged(i), field3.PointerSharedManaged(i), field4.PointerSharedManaged(i), field5.PointerSharedManaged(i), field6.PointerSharedManaged(i), field7.PointerSharedManaged(i), field8.PointerSharedManaged(i), field9.PointerSharedManaged(i), field10.PointerSharedManaged(i), field11.PointerSharedManaged(i), field12.PointerSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSparseManaged(i), field1.PointerSparseManaged(i), field2.PointerSparseManaged(i), field3.PointerSparseManaged(i), field4.PointerSparseManaged(i), field5.PointerSparseManaged(i), field6.PointerSparseManaged(i), field7.PointerSparseManaged(i), field8.PointerSparseManaged(i), field9.PointerSparseManaged(i), field10.PointerSparseManaged(i), field11.PointerSparseManaged(i), field12.PointerSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSparseSharedManaged(i), field1.PointerSparseSharedManaged(i), field2.PointerSparseSharedManaged(i), field3.PointerSparseSharedManaged(i), field4.PointerSparseSharedManaged(i), field5.PointerSparseSharedManaged(i), field6.PointerSparseSharedManaged(i), field7.PointerSparseSharedManaged(i), field8.PointerSparseSharedManaged(i), field9.PointerSparseSharedManaged(i), field10.PointerSparseSharedManaged(i), field11.PointerSparseSharedManaged(i), field12.PointerSparseSharedManaged(i));
+        }
     }
 }
\ No newline at end of file
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/Invoker/Each/Iterator/T14.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/Invoker/Each/Iterator/T14.g.cs
index 118bf50c..65d7b225 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/Invoker/Each/Iterator/T14.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/Invoker/Each/Iterator/T14.g.cs
@@ -1,5 +1,7 @@
 // Each/Iterator/T14.g.cs
 // File was auto-generated by /_/src/Flecs.NET.Codegen/Generators/Invoker.cs
+using System;
+using System.Runtime.CompilerServices;
 using Flecs.NET.Utilities;
 using static Flecs.NET.Bindings.flecs;
 
@@ -17,15 +19,93 @@ public static void Each<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8); byte* pointer9 = (byte*)it.GetPointer<T9>(9); byte* pointer10 = (byte*)it.GetPointer<T10>(10); byte* pointer11 = (byte*)it.GetPointer<T11>(11); byte* pointer12 = (byte*)it.GetPointer<T12>(12); byte* pointer13 = (byte*)it.GetPointer<T13>(13);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8); int step9 = it.Step<T9>(9); int step10 = it.Step<T10>(10); int step11 = it.Step<T11>(11); int step12 = it.Step<T12>(12); int step13 = it.Step<T13>(13);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8); FieldData<T9> field9 = it.GetFieldData<T9>(9); FieldData<T10> field10 = it.GetFieldData<T10>(10); FieldData<T11> field11 = it.GetFieldData<T11>(11); FieldData<T12> field12 = it.GetFieldData<T12>(12); FieldData<T13> field13 = it.GetFieldData<T13>(13);
+        IterationTechnique flags = it.GetIterationTechnique(14);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8], pointer9 = &pointer9[step9], pointer10 = &pointer10[step10], pointer11 = &pointer11[step11], pointer12 = &pointer12[step12], pointer13 = &pointer13[step13])
-            callback(ref Managed.GetTypeRef<T0>(pointer0), ref Managed.GetTypeRef<T1>(pointer1), ref Managed.GetTypeRef<T2>(pointer2), ref Managed.GetTypeRef<T3>(pointer3), ref Managed.GetTypeRef<T4>(pointer4), ref Managed.GetTypeRef<T5>(pointer5), ref Managed.GetTypeRef<T6>(pointer6), ref Managed.GetTypeRef<T7>(pointer7), ref Managed.GetTypeRef<T8>(pointer8), ref Managed.GetTypeRef<T9>(pointer9), ref Managed.GetTypeRef<T10>(pointer10), ref Managed.GetTypeRef<T11>(pointer11), ref Managed.GetTypeRef<T12>(pointer12), ref Managed.GetTypeRef<T13>(pointer13));
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>() || RuntimeHelpers.IsReferenceOrContainsReferences<T9>() || RuntimeHelpers.IsReferenceOrContainsReferences<T10>() || RuntimeHelpers.IsReferenceOrContainsReferences<T11>() || RuntimeHelpers.IsReferenceOrContainsReferences<T12>() || RuntimeHelpers.IsReferenceOrContainsReferences<T13>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefUnmanaged(i), ref field1.RefUnmanaged(i), ref field2.RefUnmanaged(i), ref field3.RefUnmanaged(i), ref field4.RefUnmanaged(i), ref field5.RefUnmanaged(i), ref field6.RefUnmanaged(i), ref field7.RefUnmanaged(i), ref field8.RefUnmanaged(i), ref field9.RefUnmanaged(i), ref field10.RefUnmanaged(i), ref field11.RefUnmanaged(i), ref field12.RefUnmanaged(i), ref field13.RefUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSharedUnmanaged(i), ref field1.RefSharedUnmanaged(i), ref field2.RefSharedUnmanaged(i), ref field3.RefSharedUnmanaged(i), ref field4.RefSharedUnmanaged(i), ref field5.RefSharedUnmanaged(i), ref field6.RefSharedUnmanaged(i), ref field7.RefSharedUnmanaged(i), ref field8.RefSharedUnmanaged(i), ref field9.RefSharedUnmanaged(i), ref field10.RefSharedUnmanaged(i), ref field11.RefSharedUnmanaged(i), ref field12.RefSharedUnmanaged(i), ref field13.RefSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSparseUnmanaged(i), ref field1.RefSparseUnmanaged(i), ref field2.RefSparseUnmanaged(i), ref field3.RefSparseUnmanaged(i), ref field4.RefSparseUnmanaged(i), ref field5.RefSparseUnmanaged(i), ref field6.RefSparseUnmanaged(i), ref field7.RefSparseUnmanaged(i), ref field8.RefSparseUnmanaged(i), ref field9.RefSparseUnmanaged(i), ref field10.RefSparseUnmanaged(i), ref field11.RefSparseUnmanaged(i), ref field12.RefSparseUnmanaged(i), ref field13.RefSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSparseSharedUnmanaged(i), ref field1.RefSparseSharedUnmanaged(i), ref field2.RefSparseSharedUnmanaged(i), ref field3.RefSparseSharedUnmanaged(i), ref field4.RefSparseSharedUnmanaged(i), ref field5.RefSparseSharedUnmanaged(i), ref field6.RefSparseSharedUnmanaged(i), ref field7.RefSparseSharedUnmanaged(i), ref field8.RefSparseSharedUnmanaged(i), ref field9.RefSparseSharedUnmanaged(i), ref field10.RefSparseSharedUnmanaged(i), ref field11.RefSparseSharedUnmanaged(i), ref field12.RefSparseSharedUnmanaged(i), ref field13.RefSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefManaged(i), ref field1.RefManaged(i), ref field2.RefManaged(i), ref field3.RefManaged(i), ref field4.RefManaged(i), ref field5.RefManaged(i), ref field6.RefManaged(i), ref field7.RefManaged(i), ref field8.RefManaged(i), ref field9.RefManaged(i), ref field10.RefManaged(i), ref field11.RefManaged(i), ref field12.RefManaged(i), ref field13.RefManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSharedManaged(i), ref field1.RefSharedManaged(i), ref field2.RefSharedManaged(i), ref field3.RefSharedManaged(i), ref field4.RefSharedManaged(i), ref field5.RefSharedManaged(i), ref field6.RefSharedManaged(i), ref field7.RefSharedManaged(i), ref field8.RefSharedManaged(i), ref field9.RefSharedManaged(i), ref field10.RefSharedManaged(i), ref field11.RefSharedManaged(i), ref field12.RefSharedManaged(i), ref field13.RefSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSparseManaged(i), ref field1.RefSparseManaged(i), ref field2.RefSparseManaged(i), ref field3.RefSparseManaged(i), ref field4.RefSparseManaged(i), ref field5.RefSparseManaged(i), ref field6.RefSparseManaged(i), ref field7.RefSparseManaged(i), ref field8.RefSparseManaged(i), ref field9.RefSparseManaged(i), ref field10.RefSparseManaged(i), ref field11.RefSparseManaged(i), ref field12.RefSparseManaged(i), ref field13.RefSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSparseSharedManaged(i), ref field1.RefSparseSharedManaged(i), ref field2.RefSparseSharedManaged(i), ref field3.RefSparseSharedManaged(i), ref field4.RefSparseSharedManaged(i), ref field5.RefSparseSharedManaged(i), ref field6.RefSparseSharedManaged(i), ref field7.RefSparseSharedManaged(i), ref field8.RefSparseSharedManaged(i), ref field9.RefSparseSharedManaged(i), ref field10.RefSparseSharedManaged(i), ref field11.RefSparseSharedManaged(i), ref field12.RefSparseSharedManaged(i), ref field13.RefSparseSharedManaged(i));
+        }
     }
 
     /// <summary>
@@ -38,15 +118,93 @@ public static void Each<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T
     {
         int count = it.Handle->count; Ecs.Assert(it.Handle->count > 0, "No entities returned, use Iter() or Each() without the entity argument instead.");
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8); byte* pointer9 = (byte*)it.GetPointer<T9>(9); byte* pointer10 = (byte*)it.GetPointer<T10>(10); byte* pointer11 = (byte*)it.GetPointer<T11>(11); byte* pointer12 = (byte*)it.GetPointer<T12>(12); byte* pointer13 = (byte*)it.GetPointer<T13>(13);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8); int step9 = it.Step<T9>(9); int step10 = it.Step<T10>(10); int step11 = it.Step<T11>(11); int step12 = it.Step<T12>(12); int step13 = it.Step<T13>(13);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8); FieldData<T9> field9 = it.GetFieldData<T9>(9); FieldData<T10> field10 = it.GetFieldData<T10>(10); FieldData<T11> field11 = it.GetFieldData<T11>(11); FieldData<T12> field12 = it.GetFieldData<T12>(12); FieldData<T13> field13 = it.GetFieldData<T13>(13);
+        IterationTechnique flags = it.GetIterationTechnique(14);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8], pointer9 = &pointer9[step9], pointer10 = &pointer10[step10], pointer11 = &pointer11[step11], pointer12 = &pointer12[step12], pointer13 = &pointer13[step13])
-            callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref Managed.GetTypeRef<T0>(pointer0), ref Managed.GetTypeRef<T1>(pointer1), ref Managed.GetTypeRef<T2>(pointer2), ref Managed.GetTypeRef<T3>(pointer3), ref Managed.GetTypeRef<T4>(pointer4), ref Managed.GetTypeRef<T5>(pointer5), ref Managed.GetTypeRef<T6>(pointer6), ref Managed.GetTypeRef<T7>(pointer7), ref Managed.GetTypeRef<T8>(pointer8), ref Managed.GetTypeRef<T9>(pointer9), ref Managed.GetTypeRef<T10>(pointer10), ref Managed.GetTypeRef<T11>(pointer11), ref Managed.GetTypeRef<T12>(pointer12), ref Managed.GetTypeRef<T13>(pointer13));
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>() || RuntimeHelpers.IsReferenceOrContainsReferences<T9>() || RuntimeHelpers.IsReferenceOrContainsReferences<T10>() || RuntimeHelpers.IsReferenceOrContainsReferences<T11>() || RuntimeHelpers.IsReferenceOrContainsReferences<T12>() || RuntimeHelpers.IsReferenceOrContainsReferences<T13>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefUnmanaged(i), ref field1.RefUnmanaged(i), ref field2.RefUnmanaged(i), ref field3.RefUnmanaged(i), ref field4.RefUnmanaged(i), ref field5.RefUnmanaged(i), ref field6.RefUnmanaged(i), ref field7.RefUnmanaged(i), ref field8.RefUnmanaged(i), ref field9.RefUnmanaged(i), ref field10.RefUnmanaged(i), ref field11.RefUnmanaged(i), ref field12.RefUnmanaged(i), ref field13.RefUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSharedUnmanaged(i), ref field1.RefSharedUnmanaged(i), ref field2.RefSharedUnmanaged(i), ref field3.RefSharedUnmanaged(i), ref field4.RefSharedUnmanaged(i), ref field5.RefSharedUnmanaged(i), ref field6.RefSharedUnmanaged(i), ref field7.RefSharedUnmanaged(i), ref field8.RefSharedUnmanaged(i), ref field9.RefSharedUnmanaged(i), ref field10.RefSharedUnmanaged(i), ref field11.RefSharedUnmanaged(i), ref field12.RefSharedUnmanaged(i), ref field13.RefSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseUnmanaged(i), ref field1.RefSparseUnmanaged(i), ref field2.RefSparseUnmanaged(i), ref field3.RefSparseUnmanaged(i), ref field4.RefSparseUnmanaged(i), ref field5.RefSparseUnmanaged(i), ref field6.RefSparseUnmanaged(i), ref field7.RefSparseUnmanaged(i), ref field8.RefSparseUnmanaged(i), ref field9.RefSparseUnmanaged(i), ref field10.RefSparseUnmanaged(i), ref field11.RefSparseUnmanaged(i), ref field12.RefSparseUnmanaged(i), ref field13.RefSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseSharedUnmanaged(i), ref field1.RefSparseSharedUnmanaged(i), ref field2.RefSparseSharedUnmanaged(i), ref field3.RefSparseSharedUnmanaged(i), ref field4.RefSparseSharedUnmanaged(i), ref field5.RefSparseSharedUnmanaged(i), ref field6.RefSparseSharedUnmanaged(i), ref field7.RefSparseSharedUnmanaged(i), ref field8.RefSparseSharedUnmanaged(i), ref field9.RefSparseSharedUnmanaged(i), ref field10.RefSparseSharedUnmanaged(i), ref field11.RefSparseSharedUnmanaged(i), ref field12.RefSparseSharedUnmanaged(i), ref field13.RefSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefManaged(i), ref field1.RefManaged(i), ref field2.RefManaged(i), ref field3.RefManaged(i), ref field4.RefManaged(i), ref field5.RefManaged(i), ref field6.RefManaged(i), ref field7.RefManaged(i), ref field8.RefManaged(i), ref field9.RefManaged(i), ref field10.RefManaged(i), ref field11.RefManaged(i), ref field12.RefManaged(i), ref field13.RefManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSharedManaged(i), ref field1.RefSharedManaged(i), ref field2.RefSharedManaged(i), ref field3.RefSharedManaged(i), ref field4.RefSharedManaged(i), ref field5.RefSharedManaged(i), ref field6.RefSharedManaged(i), ref field7.RefSharedManaged(i), ref field8.RefSharedManaged(i), ref field9.RefSharedManaged(i), ref field10.RefSharedManaged(i), ref field11.RefSharedManaged(i), ref field12.RefSharedManaged(i), ref field13.RefSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseManaged(i), ref field1.RefSparseManaged(i), ref field2.RefSparseManaged(i), ref field3.RefSparseManaged(i), ref field4.RefSparseManaged(i), ref field5.RefSparseManaged(i), ref field6.RefSparseManaged(i), ref field7.RefSparseManaged(i), ref field8.RefSparseManaged(i), ref field9.RefSparseManaged(i), ref field10.RefSparseManaged(i), ref field11.RefSparseManaged(i), ref field12.RefSparseManaged(i), ref field13.RefSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseSharedManaged(i), ref field1.RefSparseSharedManaged(i), ref field2.RefSparseSharedManaged(i), ref field3.RefSparseSharedManaged(i), ref field4.RefSparseSharedManaged(i), ref field5.RefSparseSharedManaged(i), ref field6.RefSparseSharedManaged(i), ref field7.RefSparseSharedManaged(i), ref field8.RefSparseSharedManaged(i), ref field9.RefSparseSharedManaged(i), ref field10.RefSparseSharedManaged(i), ref field11.RefSparseSharedManaged(i), ref field12.RefSparseSharedManaged(i), ref field13.RefSparseSharedManaged(i));
+        }
     }
 
     /// <summary>
@@ -59,15 +217,93 @@ public static void Each<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8); byte* pointer9 = (byte*)it.GetPointer<T9>(9); byte* pointer10 = (byte*)it.GetPointer<T10>(10); byte* pointer11 = (byte*)it.GetPointer<T11>(11); byte* pointer12 = (byte*)it.GetPointer<T12>(12); byte* pointer13 = (byte*)it.GetPointer<T13>(13);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8); int step9 = it.Step<T9>(9); int step10 = it.Step<T10>(10); int step11 = it.Step<T11>(11); int step12 = it.Step<T12>(12); int step13 = it.Step<T13>(13);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8); FieldData<T9> field9 = it.GetFieldData<T9>(9); FieldData<T10> field10 = it.GetFieldData<T10>(10); FieldData<T11> field11 = it.GetFieldData<T11>(11); FieldData<T12> field12 = it.GetFieldData<T12>(12); FieldData<T13> field13 = it.GetFieldData<T13>(13);
+        IterationTechnique flags = it.GetIterationTechnique(14);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8], pointer9 = &pointer9[step9], pointer10 = &pointer10[step10], pointer11 = &pointer11[step11], pointer12 = &pointer12[step12], pointer13 = &pointer13[step13])
-            callback(it, i, ref Managed.GetTypeRef<T0>(pointer0), ref Managed.GetTypeRef<T1>(pointer1), ref Managed.GetTypeRef<T2>(pointer2), ref Managed.GetTypeRef<T3>(pointer3), ref Managed.GetTypeRef<T4>(pointer4), ref Managed.GetTypeRef<T5>(pointer5), ref Managed.GetTypeRef<T6>(pointer6), ref Managed.GetTypeRef<T7>(pointer7), ref Managed.GetTypeRef<T8>(pointer8), ref Managed.GetTypeRef<T9>(pointer9), ref Managed.GetTypeRef<T10>(pointer10), ref Managed.GetTypeRef<T11>(pointer11), ref Managed.GetTypeRef<T12>(pointer12), ref Managed.GetTypeRef<T13>(pointer13));
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>() || RuntimeHelpers.IsReferenceOrContainsReferences<T9>() || RuntimeHelpers.IsReferenceOrContainsReferences<T10>() || RuntimeHelpers.IsReferenceOrContainsReferences<T11>() || RuntimeHelpers.IsReferenceOrContainsReferences<T12>() || RuntimeHelpers.IsReferenceOrContainsReferences<T13>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefUnmanaged(i), ref field1.RefUnmanaged(i), ref field2.RefUnmanaged(i), ref field3.RefUnmanaged(i), ref field4.RefUnmanaged(i), ref field5.RefUnmanaged(i), ref field6.RefUnmanaged(i), ref field7.RefUnmanaged(i), ref field8.RefUnmanaged(i), ref field9.RefUnmanaged(i), ref field10.RefUnmanaged(i), ref field11.RefUnmanaged(i), ref field12.RefUnmanaged(i), ref field13.RefUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSharedUnmanaged(i), ref field1.RefSharedUnmanaged(i), ref field2.RefSharedUnmanaged(i), ref field3.RefSharedUnmanaged(i), ref field4.RefSharedUnmanaged(i), ref field5.RefSharedUnmanaged(i), ref field6.RefSharedUnmanaged(i), ref field7.RefSharedUnmanaged(i), ref field8.RefSharedUnmanaged(i), ref field9.RefSharedUnmanaged(i), ref field10.RefSharedUnmanaged(i), ref field11.RefSharedUnmanaged(i), ref field12.RefSharedUnmanaged(i), ref field13.RefSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSparseUnmanaged(i), ref field1.RefSparseUnmanaged(i), ref field2.RefSparseUnmanaged(i), ref field3.RefSparseUnmanaged(i), ref field4.RefSparseUnmanaged(i), ref field5.RefSparseUnmanaged(i), ref field6.RefSparseUnmanaged(i), ref field7.RefSparseUnmanaged(i), ref field8.RefSparseUnmanaged(i), ref field9.RefSparseUnmanaged(i), ref field10.RefSparseUnmanaged(i), ref field11.RefSparseUnmanaged(i), ref field12.RefSparseUnmanaged(i), ref field13.RefSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSparseSharedUnmanaged(i), ref field1.RefSparseSharedUnmanaged(i), ref field2.RefSparseSharedUnmanaged(i), ref field3.RefSparseSharedUnmanaged(i), ref field4.RefSparseSharedUnmanaged(i), ref field5.RefSparseSharedUnmanaged(i), ref field6.RefSparseSharedUnmanaged(i), ref field7.RefSparseSharedUnmanaged(i), ref field8.RefSparseSharedUnmanaged(i), ref field9.RefSparseSharedUnmanaged(i), ref field10.RefSparseSharedUnmanaged(i), ref field11.RefSparseSharedUnmanaged(i), ref field12.RefSparseSharedUnmanaged(i), ref field13.RefSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefManaged(i), ref field1.RefManaged(i), ref field2.RefManaged(i), ref field3.RefManaged(i), ref field4.RefManaged(i), ref field5.RefManaged(i), ref field6.RefManaged(i), ref field7.RefManaged(i), ref field8.RefManaged(i), ref field9.RefManaged(i), ref field10.RefManaged(i), ref field11.RefManaged(i), ref field12.RefManaged(i), ref field13.RefManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSharedManaged(i), ref field1.RefSharedManaged(i), ref field2.RefSharedManaged(i), ref field3.RefSharedManaged(i), ref field4.RefSharedManaged(i), ref field5.RefSharedManaged(i), ref field6.RefSharedManaged(i), ref field7.RefSharedManaged(i), ref field8.RefSharedManaged(i), ref field9.RefSharedManaged(i), ref field10.RefSharedManaged(i), ref field11.RefSharedManaged(i), ref field12.RefSharedManaged(i), ref field13.RefSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSparseManaged(i), ref field1.RefSparseManaged(i), ref field2.RefSparseManaged(i), ref field3.RefSparseManaged(i), ref field4.RefSparseManaged(i), ref field5.RefSparseManaged(i), ref field6.RefSparseManaged(i), ref field7.RefSparseManaged(i), ref field8.RefSparseManaged(i), ref field9.RefSparseManaged(i), ref field10.RefSparseManaged(i), ref field11.RefSparseManaged(i), ref field12.RefSparseManaged(i), ref field13.RefSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSparseSharedManaged(i), ref field1.RefSparseSharedManaged(i), ref field2.RefSparseSharedManaged(i), ref field3.RefSparseSharedManaged(i), ref field4.RefSparseSharedManaged(i), ref field5.RefSparseSharedManaged(i), ref field6.RefSparseSharedManaged(i), ref field7.RefSparseSharedManaged(i), ref field8.RefSparseSharedManaged(i), ref field9.RefSparseSharedManaged(i), ref field10.RefSparseSharedManaged(i), ref field11.RefSparseSharedManaged(i), ref field12.RefSparseSharedManaged(i), ref field13.RefSparseSharedManaged(i));
+        }
     }
 
     /// <summary>
@@ -80,15 +316,93 @@ public static void Each<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8); byte* pointer9 = (byte*)it.GetPointer<T9>(9); byte* pointer10 = (byte*)it.GetPointer<T10>(10); byte* pointer11 = (byte*)it.GetPointer<T11>(11); byte* pointer12 = (byte*)it.GetPointer<T12>(12); byte* pointer13 = (byte*)it.GetPointer<T13>(13);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8); int step9 = it.Step<T9>(9); int step10 = it.Step<T10>(10); int step11 = it.Step<T11>(11); int step12 = it.Step<T12>(12); int step13 = it.Step<T13>(13);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8); FieldData<T9> field9 = it.GetFieldData<T9>(9); FieldData<T10> field10 = it.GetFieldData<T10>(10); FieldData<T11> field11 = it.GetFieldData<T11>(11); FieldData<T12> field12 = it.GetFieldData<T12>(12); FieldData<T13> field13 = it.GetFieldData<T13>(13);
+        IterationTechnique flags = it.GetIterationTechnique(14);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8], pointer9 = &pointer9[step9], pointer10 = &pointer10[step10], pointer11 = &pointer11[step11], pointer12 = &pointer12[step12], pointer13 = &pointer13[step13])
-            callback(ref Managed.GetTypeRef<T0>(pointer0), ref Managed.GetTypeRef<T1>(pointer1), ref Managed.GetTypeRef<T2>(pointer2), ref Managed.GetTypeRef<T3>(pointer3), ref Managed.GetTypeRef<T4>(pointer4), ref Managed.GetTypeRef<T5>(pointer5), ref Managed.GetTypeRef<T6>(pointer6), ref Managed.GetTypeRef<T7>(pointer7), ref Managed.GetTypeRef<T8>(pointer8), ref Managed.GetTypeRef<T9>(pointer9), ref Managed.GetTypeRef<T10>(pointer10), ref Managed.GetTypeRef<T11>(pointer11), ref Managed.GetTypeRef<T12>(pointer12), ref Managed.GetTypeRef<T13>(pointer13));
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>() || RuntimeHelpers.IsReferenceOrContainsReferences<T9>() || RuntimeHelpers.IsReferenceOrContainsReferences<T10>() || RuntimeHelpers.IsReferenceOrContainsReferences<T11>() || RuntimeHelpers.IsReferenceOrContainsReferences<T12>() || RuntimeHelpers.IsReferenceOrContainsReferences<T13>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefUnmanaged(i), ref field1.RefUnmanaged(i), ref field2.RefUnmanaged(i), ref field3.RefUnmanaged(i), ref field4.RefUnmanaged(i), ref field5.RefUnmanaged(i), ref field6.RefUnmanaged(i), ref field7.RefUnmanaged(i), ref field8.RefUnmanaged(i), ref field9.RefUnmanaged(i), ref field10.RefUnmanaged(i), ref field11.RefUnmanaged(i), ref field12.RefUnmanaged(i), ref field13.RefUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSharedUnmanaged(i), ref field1.RefSharedUnmanaged(i), ref field2.RefSharedUnmanaged(i), ref field3.RefSharedUnmanaged(i), ref field4.RefSharedUnmanaged(i), ref field5.RefSharedUnmanaged(i), ref field6.RefSharedUnmanaged(i), ref field7.RefSharedUnmanaged(i), ref field8.RefSharedUnmanaged(i), ref field9.RefSharedUnmanaged(i), ref field10.RefSharedUnmanaged(i), ref field11.RefSharedUnmanaged(i), ref field12.RefSharedUnmanaged(i), ref field13.RefSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSparseUnmanaged(i), ref field1.RefSparseUnmanaged(i), ref field2.RefSparseUnmanaged(i), ref field3.RefSparseUnmanaged(i), ref field4.RefSparseUnmanaged(i), ref field5.RefSparseUnmanaged(i), ref field6.RefSparseUnmanaged(i), ref field7.RefSparseUnmanaged(i), ref field8.RefSparseUnmanaged(i), ref field9.RefSparseUnmanaged(i), ref field10.RefSparseUnmanaged(i), ref field11.RefSparseUnmanaged(i), ref field12.RefSparseUnmanaged(i), ref field13.RefSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSparseSharedUnmanaged(i), ref field1.RefSparseSharedUnmanaged(i), ref field2.RefSparseSharedUnmanaged(i), ref field3.RefSparseSharedUnmanaged(i), ref field4.RefSparseSharedUnmanaged(i), ref field5.RefSparseSharedUnmanaged(i), ref field6.RefSparseSharedUnmanaged(i), ref field7.RefSparseSharedUnmanaged(i), ref field8.RefSparseSharedUnmanaged(i), ref field9.RefSparseSharedUnmanaged(i), ref field10.RefSparseSharedUnmanaged(i), ref field11.RefSparseSharedUnmanaged(i), ref field12.RefSparseSharedUnmanaged(i), ref field13.RefSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefManaged(i), ref field1.RefManaged(i), ref field2.RefManaged(i), ref field3.RefManaged(i), ref field4.RefManaged(i), ref field5.RefManaged(i), ref field6.RefManaged(i), ref field7.RefManaged(i), ref field8.RefManaged(i), ref field9.RefManaged(i), ref field10.RefManaged(i), ref field11.RefManaged(i), ref field12.RefManaged(i), ref field13.RefManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSharedManaged(i), ref field1.RefSharedManaged(i), ref field2.RefSharedManaged(i), ref field3.RefSharedManaged(i), ref field4.RefSharedManaged(i), ref field5.RefSharedManaged(i), ref field6.RefSharedManaged(i), ref field7.RefSharedManaged(i), ref field8.RefSharedManaged(i), ref field9.RefSharedManaged(i), ref field10.RefSharedManaged(i), ref field11.RefSharedManaged(i), ref field12.RefSharedManaged(i), ref field13.RefSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSparseManaged(i), ref field1.RefSparseManaged(i), ref field2.RefSparseManaged(i), ref field3.RefSparseManaged(i), ref field4.RefSparseManaged(i), ref field5.RefSparseManaged(i), ref field6.RefSparseManaged(i), ref field7.RefSparseManaged(i), ref field8.RefSparseManaged(i), ref field9.RefSparseManaged(i), ref field10.RefSparseManaged(i), ref field11.RefSparseManaged(i), ref field12.RefSparseManaged(i), ref field13.RefSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSparseSharedManaged(i), ref field1.RefSparseSharedManaged(i), ref field2.RefSparseSharedManaged(i), ref field3.RefSparseSharedManaged(i), ref field4.RefSparseSharedManaged(i), ref field5.RefSparseSharedManaged(i), ref field6.RefSparseSharedManaged(i), ref field7.RefSparseSharedManaged(i), ref field8.RefSparseSharedManaged(i), ref field9.RefSparseSharedManaged(i), ref field10.RefSparseSharedManaged(i), ref field11.RefSparseSharedManaged(i), ref field12.RefSparseSharedManaged(i), ref field13.RefSparseSharedManaged(i));
+        }
     }
 
     /// <summary>
@@ -101,15 +415,93 @@ public static void Each<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T
     {
         int count = it.Handle->count; Ecs.Assert(it.Handle->count > 0, "No entities returned, use Iter() or Each() without the entity argument instead.");
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8); byte* pointer9 = (byte*)it.GetPointer<T9>(9); byte* pointer10 = (byte*)it.GetPointer<T10>(10); byte* pointer11 = (byte*)it.GetPointer<T11>(11); byte* pointer12 = (byte*)it.GetPointer<T12>(12); byte* pointer13 = (byte*)it.GetPointer<T13>(13);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8); int step9 = it.Step<T9>(9); int step10 = it.Step<T10>(10); int step11 = it.Step<T11>(11); int step12 = it.Step<T12>(12); int step13 = it.Step<T13>(13);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8); FieldData<T9> field9 = it.GetFieldData<T9>(9); FieldData<T10> field10 = it.GetFieldData<T10>(10); FieldData<T11> field11 = it.GetFieldData<T11>(11); FieldData<T12> field12 = it.GetFieldData<T12>(12); FieldData<T13> field13 = it.GetFieldData<T13>(13);
+        IterationTechnique flags = it.GetIterationTechnique(14);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8], pointer9 = &pointer9[step9], pointer10 = &pointer10[step10], pointer11 = &pointer11[step11], pointer12 = &pointer12[step12], pointer13 = &pointer13[step13])
-            callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref Managed.GetTypeRef<T0>(pointer0), ref Managed.GetTypeRef<T1>(pointer1), ref Managed.GetTypeRef<T2>(pointer2), ref Managed.GetTypeRef<T3>(pointer3), ref Managed.GetTypeRef<T4>(pointer4), ref Managed.GetTypeRef<T5>(pointer5), ref Managed.GetTypeRef<T6>(pointer6), ref Managed.GetTypeRef<T7>(pointer7), ref Managed.GetTypeRef<T8>(pointer8), ref Managed.GetTypeRef<T9>(pointer9), ref Managed.GetTypeRef<T10>(pointer10), ref Managed.GetTypeRef<T11>(pointer11), ref Managed.GetTypeRef<T12>(pointer12), ref Managed.GetTypeRef<T13>(pointer13));
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>() || RuntimeHelpers.IsReferenceOrContainsReferences<T9>() || RuntimeHelpers.IsReferenceOrContainsReferences<T10>() || RuntimeHelpers.IsReferenceOrContainsReferences<T11>() || RuntimeHelpers.IsReferenceOrContainsReferences<T12>() || RuntimeHelpers.IsReferenceOrContainsReferences<T13>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefUnmanaged(i), ref field1.RefUnmanaged(i), ref field2.RefUnmanaged(i), ref field3.RefUnmanaged(i), ref field4.RefUnmanaged(i), ref field5.RefUnmanaged(i), ref field6.RefUnmanaged(i), ref field7.RefUnmanaged(i), ref field8.RefUnmanaged(i), ref field9.RefUnmanaged(i), ref field10.RefUnmanaged(i), ref field11.RefUnmanaged(i), ref field12.RefUnmanaged(i), ref field13.RefUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSharedUnmanaged(i), ref field1.RefSharedUnmanaged(i), ref field2.RefSharedUnmanaged(i), ref field3.RefSharedUnmanaged(i), ref field4.RefSharedUnmanaged(i), ref field5.RefSharedUnmanaged(i), ref field6.RefSharedUnmanaged(i), ref field7.RefSharedUnmanaged(i), ref field8.RefSharedUnmanaged(i), ref field9.RefSharedUnmanaged(i), ref field10.RefSharedUnmanaged(i), ref field11.RefSharedUnmanaged(i), ref field12.RefSharedUnmanaged(i), ref field13.RefSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseUnmanaged(i), ref field1.RefSparseUnmanaged(i), ref field2.RefSparseUnmanaged(i), ref field3.RefSparseUnmanaged(i), ref field4.RefSparseUnmanaged(i), ref field5.RefSparseUnmanaged(i), ref field6.RefSparseUnmanaged(i), ref field7.RefSparseUnmanaged(i), ref field8.RefSparseUnmanaged(i), ref field9.RefSparseUnmanaged(i), ref field10.RefSparseUnmanaged(i), ref field11.RefSparseUnmanaged(i), ref field12.RefSparseUnmanaged(i), ref field13.RefSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseSharedUnmanaged(i), ref field1.RefSparseSharedUnmanaged(i), ref field2.RefSparseSharedUnmanaged(i), ref field3.RefSparseSharedUnmanaged(i), ref field4.RefSparseSharedUnmanaged(i), ref field5.RefSparseSharedUnmanaged(i), ref field6.RefSparseSharedUnmanaged(i), ref field7.RefSparseSharedUnmanaged(i), ref field8.RefSparseSharedUnmanaged(i), ref field9.RefSparseSharedUnmanaged(i), ref field10.RefSparseSharedUnmanaged(i), ref field11.RefSparseSharedUnmanaged(i), ref field12.RefSparseSharedUnmanaged(i), ref field13.RefSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefManaged(i), ref field1.RefManaged(i), ref field2.RefManaged(i), ref field3.RefManaged(i), ref field4.RefManaged(i), ref field5.RefManaged(i), ref field6.RefManaged(i), ref field7.RefManaged(i), ref field8.RefManaged(i), ref field9.RefManaged(i), ref field10.RefManaged(i), ref field11.RefManaged(i), ref field12.RefManaged(i), ref field13.RefManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSharedManaged(i), ref field1.RefSharedManaged(i), ref field2.RefSharedManaged(i), ref field3.RefSharedManaged(i), ref field4.RefSharedManaged(i), ref field5.RefSharedManaged(i), ref field6.RefSharedManaged(i), ref field7.RefSharedManaged(i), ref field8.RefSharedManaged(i), ref field9.RefSharedManaged(i), ref field10.RefSharedManaged(i), ref field11.RefSharedManaged(i), ref field12.RefSharedManaged(i), ref field13.RefSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseManaged(i), ref field1.RefSparseManaged(i), ref field2.RefSparseManaged(i), ref field3.RefSparseManaged(i), ref field4.RefSparseManaged(i), ref field5.RefSparseManaged(i), ref field6.RefSparseManaged(i), ref field7.RefSparseManaged(i), ref field8.RefSparseManaged(i), ref field9.RefSparseManaged(i), ref field10.RefSparseManaged(i), ref field11.RefSparseManaged(i), ref field12.RefSparseManaged(i), ref field13.RefSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseSharedManaged(i), ref field1.RefSparseSharedManaged(i), ref field2.RefSparseSharedManaged(i), ref field3.RefSparseSharedManaged(i), ref field4.RefSparseSharedManaged(i), ref field5.RefSparseSharedManaged(i), ref field6.RefSparseSharedManaged(i), ref field7.RefSparseSharedManaged(i), ref field8.RefSparseSharedManaged(i), ref field9.RefSparseSharedManaged(i), ref field10.RefSparseSharedManaged(i), ref field11.RefSparseSharedManaged(i), ref field12.RefSparseSharedManaged(i), ref field13.RefSparseSharedManaged(i));
+        }
     }
 
     /// <summary>
@@ -122,15 +514,93 @@ public static void Each<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8); byte* pointer9 = (byte*)it.GetPointer<T9>(9); byte* pointer10 = (byte*)it.GetPointer<T10>(10); byte* pointer11 = (byte*)it.GetPointer<T11>(11); byte* pointer12 = (byte*)it.GetPointer<T12>(12); byte* pointer13 = (byte*)it.GetPointer<T13>(13);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8); int step9 = it.Step<T9>(9); int step10 = it.Step<T10>(10); int step11 = it.Step<T11>(11); int step12 = it.Step<T12>(12); int step13 = it.Step<T13>(13);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8); FieldData<T9> field9 = it.GetFieldData<T9>(9); FieldData<T10> field10 = it.GetFieldData<T10>(10); FieldData<T11> field11 = it.GetFieldData<T11>(11); FieldData<T12> field12 = it.GetFieldData<T12>(12); FieldData<T13> field13 = it.GetFieldData<T13>(13);
+        IterationTechnique flags = it.GetIterationTechnique(14);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8], pointer9 = &pointer9[step9], pointer10 = &pointer10[step10], pointer11 = &pointer11[step11], pointer12 = &pointer12[step12], pointer13 = &pointer13[step13])
-            callback(it, i, ref Managed.GetTypeRef<T0>(pointer0), ref Managed.GetTypeRef<T1>(pointer1), ref Managed.GetTypeRef<T2>(pointer2), ref Managed.GetTypeRef<T3>(pointer3), ref Managed.GetTypeRef<T4>(pointer4), ref Managed.GetTypeRef<T5>(pointer5), ref Managed.GetTypeRef<T6>(pointer6), ref Managed.GetTypeRef<T7>(pointer7), ref Managed.GetTypeRef<T8>(pointer8), ref Managed.GetTypeRef<T9>(pointer9), ref Managed.GetTypeRef<T10>(pointer10), ref Managed.GetTypeRef<T11>(pointer11), ref Managed.GetTypeRef<T12>(pointer12), ref Managed.GetTypeRef<T13>(pointer13));
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>() || RuntimeHelpers.IsReferenceOrContainsReferences<T9>() || RuntimeHelpers.IsReferenceOrContainsReferences<T10>() || RuntimeHelpers.IsReferenceOrContainsReferences<T11>() || RuntimeHelpers.IsReferenceOrContainsReferences<T12>() || RuntimeHelpers.IsReferenceOrContainsReferences<T13>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefUnmanaged(i), ref field1.RefUnmanaged(i), ref field2.RefUnmanaged(i), ref field3.RefUnmanaged(i), ref field4.RefUnmanaged(i), ref field5.RefUnmanaged(i), ref field6.RefUnmanaged(i), ref field7.RefUnmanaged(i), ref field8.RefUnmanaged(i), ref field9.RefUnmanaged(i), ref field10.RefUnmanaged(i), ref field11.RefUnmanaged(i), ref field12.RefUnmanaged(i), ref field13.RefUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSharedUnmanaged(i), ref field1.RefSharedUnmanaged(i), ref field2.RefSharedUnmanaged(i), ref field3.RefSharedUnmanaged(i), ref field4.RefSharedUnmanaged(i), ref field5.RefSharedUnmanaged(i), ref field6.RefSharedUnmanaged(i), ref field7.RefSharedUnmanaged(i), ref field8.RefSharedUnmanaged(i), ref field9.RefSharedUnmanaged(i), ref field10.RefSharedUnmanaged(i), ref field11.RefSharedUnmanaged(i), ref field12.RefSharedUnmanaged(i), ref field13.RefSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSparseUnmanaged(i), ref field1.RefSparseUnmanaged(i), ref field2.RefSparseUnmanaged(i), ref field3.RefSparseUnmanaged(i), ref field4.RefSparseUnmanaged(i), ref field5.RefSparseUnmanaged(i), ref field6.RefSparseUnmanaged(i), ref field7.RefSparseUnmanaged(i), ref field8.RefSparseUnmanaged(i), ref field9.RefSparseUnmanaged(i), ref field10.RefSparseUnmanaged(i), ref field11.RefSparseUnmanaged(i), ref field12.RefSparseUnmanaged(i), ref field13.RefSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSparseSharedUnmanaged(i), ref field1.RefSparseSharedUnmanaged(i), ref field2.RefSparseSharedUnmanaged(i), ref field3.RefSparseSharedUnmanaged(i), ref field4.RefSparseSharedUnmanaged(i), ref field5.RefSparseSharedUnmanaged(i), ref field6.RefSparseSharedUnmanaged(i), ref field7.RefSparseSharedUnmanaged(i), ref field8.RefSparseSharedUnmanaged(i), ref field9.RefSparseSharedUnmanaged(i), ref field10.RefSparseSharedUnmanaged(i), ref field11.RefSparseSharedUnmanaged(i), ref field12.RefSparseSharedUnmanaged(i), ref field13.RefSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefManaged(i), ref field1.RefManaged(i), ref field2.RefManaged(i), ref field3.RefManaged(i), ref field4.RefManaged(i), ref field5.RefManaged(i), ref field6.RefManaged(i), ref field7.RefManaged(i), ref field8.RefManaged(i), ref field9.RefManaged(i), ref field10.RefManaged(i), ref field11.RefManaged(i), ref field12.RefManaged(i), ref field13.RefManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSharedManaged(i), ref field1.RefSharedManaged(i), ref field2.RefSharedManaged(i), ref field3.RefSharedManaged(i), ref field4.RefSharedManaged(i), ref field5.RefSharedManaged(i), ref field6.RefSharedManaged(i), ref field7.RefSharedManaged(i), ref field8.RefSharedManaged(i), ref field9.RefSharedManaged(i), ref field10.RefSharedManaged(i), ref field11.RefSharedManaged(i), ref field12.RefSharedManaged(i), ref field13.RefSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSparseManaged(i), ref field1.RefSparseManaged(i), ref field2.RefSparseManaged(i), ref field3.RefSparseManaged(i), ref field4.RefSparseManaged(i), ref field5.RefSparseManaged(i), ref field6.RefSparseManaged(i), ref field7.RefSparseManaged(i), ref field8.RefSparseManaged(i), ref field9.RefSparseManaged(i), ref field10.RefSparseManaged(i), ref field11.RefSparseManaged(i), ref field12.RefSparseManaged(i), ref field13.RefSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSparseSharedManaged(i), ref field1.RefSparseSharedManaged(i), ref field2.RefSparseSharedManaged(i), ref field3.RefSparseSharedManaged(i), ref field4.RefSparseSharedManaged(i), ref field5.RefSparseSharedManaged(i), ref field6.RefSparseSharedManaged(i), ref field7.RefSparseSharedManaged(i), ref field8.RefSparseSharedManaged(i), ref field9.RefSparseSharedManaged(i), ref field10.RefSparseSharedManaged(i), ref field11.RefSparseSharedManaged(i), ref field12.RefSparseSharedManaged(i), ref field13.RefSparseSharedManaged(i));
+        }
     }
 
     /// <summary>
@@ -143,15 +613,93 @@ public static void Each<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8); byte* pointer9 = (byte*)it.GetPointer<T9>(9); byte* pointer10 = (byte*)it.GetPointer<T10>(10); byte* pointer11 = (byte*)it.GetPointer<T11>(11); byte* pointer12 = (byte*)it.GetPointer<T12>(12); byte* pointer13 = (byte*)it.GetPointer<T13>(13);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8); int step9 = it.Step<T9>(9); int step10 = it.Step<T10>(10); int step11 = it.Step<T11>(11); int step12 = it.Step<T12>(12); int step13 = it.Step<T13>(13);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8); FieldData<T9> field9 = it.GetFieldData<T9>(9); FieldData<T10> field10 = it.GetFieldData<T10>(10); FieldData<T11> field11 = it.GetFieldData<T11>(11); FieldData<T12> field12 = it.GetFieldData<T12>(12); FieldData<T13> field13 = it.GetFieldData<T13>(13);
+        IterationTechnique flags = it.GetIterationTechnique(14);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8], pointer9 = &pointer9[step9], pointer10 = &pointer10[step10], pointer11 = &pointer11[step11], pointer12 = &pointer12[step12], pointer13 = &pointer13[step13])
-            callback((T0*)pointer0, (T1*)pointer1, (T2*)pointer2, (T3*)pointer3, (T4*)pointer4, (T5*)pointer5, (T6*)pointer6, (T7*)pointer7, (T8*)pointer8, (T9*)pointer9, (T10*)pointer10, (T11*)pointer11, (T12*)pointer12, (T13*)pointer13);
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>() || RuntimeHelpers.IsReferenceOrContainsReferences<T9>() || RuntimeHelpers.IsReferenceOrContainsReferences<T10>() || RuntimeHelpers.IsReferenceOrContainsReferences<T11>() || RuntimeHelpers.IsReferenceOrContainsReferences<T12>() || RuntimeHelpers.IsReferenceOrContainsReferences<T13>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerUnmanaged(i), field1.PointerUnmanaged(i), field2.PointerUnmanaged(i), field3.PointerUnmanaged(i), field4.PointerUnmanaged(i), field5.PointerUnmanaged(i), field6.PointerUnmanaged(i), field7.PointerUnmanaged(i), field8.PointerUnmanaged(i), field9.PointerUnmanaged(i), field10.PointerUnmanaged(i), field11.PointerUnmanaged(i), field12.PointerUnmanaged(i), field13.PointerUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSharedUnmanaged(i), field1.PointerSharedUnmanaged(i), field2.PointerSharedUnmanaged(i), field3.PointerSharedUnmanaged(i), field4.PointerSharedUnmanaged(i), field5.PointerSharedUnmanaged(i), field6.PointerSharedUnmanaged(i), field7.PointerSharedUnmanaged(i), field8.PointerSharedUnmanaged(i), field9.PointerSharedUnmanaged(i), field10.PointerSharedUnmanaged(i), field11.PointerSharedUnmanaged(i), field12.PointerSharedUnmanaged(i), field13.PointerSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSparseUnmanaged(i), field1.PointerSparseUnmanaged(i), field2.PointerSparseUnmanaged(i), field3.PointerSparseUnmanaged(i), field4.PointerSparseUnmanaged(i), field5.PointerSparseUnmanaged(i), field6.PointerSparseUnmanaged(i), field7.PointerSparseUnmanaged(i), field8.PointerSparseUnmanaged(i), field9.PointerSparseUnmanaged(i), field10.PointerSparseUnmanaged(i), field11.PointerSparseUnmanaged(i), field12.PointerSparseUnmanaged(i), field13.PointerSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSparseSharedUnmanaged(i), field1.PointerSparseSharedUnmanaged(i), field2.PointerSparseSharedUnmanaged(i), field3.PointerSparseSharedUnmanaged(i), field4.PointerSparseSharedUnmanaged(i), field5.PointerSparseSharedUnmanaged(i), field6.PointerSparseSharedUnmanaged(i), field7.PointerSparseSharedUnmanaged(i), field8.PointerSparseSharedUnmanaged(i), field9.PointerSparseSharedUnmanaged(i), field10.PointerSparseSharedUnmanaged(i), field11.PointerSparseSharedUnmanaged(i), field12.PointerSparseSharedUnmanaged(i), field13.PointerSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerManaged(i), field1.PointerManaged(i), field2.PointerManaged(i), field3.PointerManaged(i), field4.PointerManaged(i), field5.PointerManaged(i), field6.PointerManaged(i), field7.PointerManaged(i), field8.PointerManaged(i), field9.PointerManaged(i), field10.PointerManaged(i), field11.PointerManaged(i), field12.PointerManaged(i), field13.PointerManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSharedManaged(i), field1.PointerSharedManaged(i), field2.PointerSharedManaged(i), field3.PointerSharedManaged(i), field4.PointerSharedManaged(i), field5.PointerSharedManaged(i), field6.PointerSharedManaged(i), field7.PointerSharedManaged(i), field8.PointerSharedManaged(i), field9.PointerSharedManaged(i), field10.PointerSharedManaged(i), field11.PointerSharedManaged(i), field12.PointerSharedManaged(i), field13.PointerSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSparseManaged(i), field1.PointerSparseManaged(i), field2.PointerSparseManaged(i), field3.PointerSparseManaged(i), field4.PointerSparseManaged(i), field5.PointerSparseManaged(i), field6.PointerSparseManaged(i), field7.PointerSparseManaged(i), field8.PointerSparseManaged(i), field9.PointerSparseManaged(i), field10.PointerSparseManaged(i), field11.PointerSparseManaged(i), field12.PointerSparseManaged(i), field13.PointerSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSparseSharedManaged(i), field1.PointerSparseSharedManaged(i), field2.PointerSparseSharedManaged(i), field3.PointerSparseSharedManaged(i), field4.PointerSparseSharedManaged(i), field5.PointerSparseSharedManaged(i), field6.PointerSparseSharedManaged(i), field7.PointerSparseSharedManaged(i), field8.PointerSparseSharedManaged(i), field9.PointerSparseSharedManaged(i), field10.PointerSparseSharedManaged(i), field11.PointerSparseSharedManaged(i), field12.PointerSparseSharedManaged(i), field13.PointerSparseSharedManaged(i));
+        }
     }
 
     /// <summary>
@@ -164,15 +712,93 @@ public static void Each<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T
     {
         int count = it.Handle->count; Ecs.Assert(it.Handle->count > 0, "No entities returned, use Iter() or Each() without the entity argument instead.");
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8); byte* pointer9 = (byte*)it.GetPointer<T9>(9); byte* pointer10 = (byte*)it.GetPointer<T10>(10); byte* pointer11 = (byte*)it.GetPointer<T11>(11); byte* pointer12 = (byte*)it.GetPointer<T12>(12); byte* pointer13 = (byte*)it.GetPointer<T13>(13);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8); int step9 = it.Step<T9>(9); int step10 = it.Step<T10>(10); int step11 = it.Step<T11>(11); int step12 = it.Step<T12>(12); int step13 = it.Step<T13>(13);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8); FieldData<T9> field9 = it.GetFieldData<T9>(9); FieldData<T10> field10 = it.GetFieldData<T10>(10); FieldData<T11> field11 = it.GetFieldData<T11>(11); FieldData<T12> field12 = it.GetFieldData<T12>(12); FieldData<T13> field13 = it.GetFieldData<T13>(13);
+        IterationTechnique flags = it.GetIterationTechnique(14);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8], pointer9 = &pointer9[step9], pointer10 = &pointer10[step10], pointer11 = &pointer11[step11], pointer12 = &pointer12[step12], pointer13 = &pointer13[step13])
-            callback(new Entity(it.Handle->world, it.Handle->entities[i]), (T0*)pointer0, (T1*)pointer1, (T2*)pointer2, (T3*)pointer3, (T4*)pointer4, (T5*)pointer5, (T6*)pointer6, (T7*)pointer7, (T8*)pointer8, (T9*)pointer9, (T10*)pointer10, (T11*)pointer11, (T12*)pointer12, (T13*)pointer13);
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>() || RuntimeHelpers.IsReferenceOrContainsReferences<T9>() || RuntimeHelpers.IsReferenceOrContainsReferences<T10>() || RuntimeHelpers.IsReferenceOrContainsReferences<T11>() || RuntimeHelpers.IsReferenceOrContainsReferences<T12>() || RuntimeHelpers.IsReferenceOrContainsReferences<T13>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerUnmanaged(i), field1.PointerUnmanaged(i), field2.PointerUnmanaged(i), field3.PointerUnmanaged(i), field4.PointerUnmanaged(i), field5.PointerUnmanaged(i), field6.PointerUnmanaged(i), field7.PointerUnmanaged(i), field8.PointerUnmanaged(i), field9.PointerUnmanaged(i), field10.PointerUnmanaged(i), field11.PointerUnmanaged(i), field12.PointerUnmanaged(i), field13.PointerUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSharedUnmanaged(i), field1.PointerSharedUnmanaged(i), field2.PointerSharedUnmanaged(i), field3.PointerSharedUnmanaged(i), field4.PointerSharedUnmanaged(i), field5.PointerSharedUnmanaged(i), field6.PointerSharedUnmanaged(i), field7.PointerSharedUnmanaged(i), field8.PointerSharedUnmanaged(i), field9.PointerSharedUnmanaged(i), field10.PointerSharedUnmanaged(i), field11.PointerSharedUnmanaged(i), field12.PointerSharedUnmanaged(i), field13.PointerSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseUnmanaged(i), field1.PointerSparseUnmanaged(i), field2.PointerSparseUnmanaged(i), field3.PointerSparseUnmanaged(i), field4.PointerSparseUnmanaged(i), field5.PointerSparseUnmanaged(i), field6.PointerSparseUnmanaged(i), field7.PointerSparseUnmanaged(i), field8.PointerSparseUnmanaged(i), field9.PointerSparseUnmanaged(i), field10.PointerSparseUnmanaged(i), field11.PointerSparseUnmanaged(i), field12.PointerSparseUnmanaged(i), field13.PointerSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseSharedUnmanaged(i), field1.PointerSparseSharedUnmanaged(i), field2.PointerSparseSharedUnmanaged(i), field3.PointerSparseSharedUnmanaged(i), field4.PointerSparseSharedUnmanaged(i), field5.PointerSparseSharedUnmanaged(i), field6.PointerSparseSharedUnmanaged(i), field7.PointerSparseSharedUnmanaged(i), field8.PointerSparseSharedUnmanaged(i), field9.PointerSparseSharedUnmanaged(i), field10.PointerSparseSharedUnmanaged(i), field11.PointerSparseSharedUnmanaged(i), field12.PointerSparseSharedUnmanaged(i), field13.PointerSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerManaged(i), field1.PointerManaged(i), field2.PointerManaged(i), field3.PointerManaged(i), field4.PointerManaged(i), field5.PointerManaged(i), field6.PointerManaged(i), field7.PointerManaged(i), field8.PointerManaged(i), field9.PointerManaged(i), field10.PointerManaged(i), field11.PointerManaged(i), field12.PointerManaged(i), field13.PointerManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSharedManaged(i), field1.PointerSharedManaged(i), field2.PointerSharedManaged(i), field3.PointerSharedManaged(i), field4.PointerSharedManaged(i), field5.PointerSharedManaged(i), field6.PointerSharedManaged(i), field7.PointerSharedManaged(i), field8.PointerSharedManaged(i), field9.PointerSharedManaged(i), field10.PointerSharedManaged(i), field11.PointerSharedManaged(i), field12.PointerSharedManaged(i), field13.PointerSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseManaged(i), field1.PointerSparseManaged(i), field2.PointerSparseManaged(i), field3.PointerSparseManaged(i), field4.PointerSparseManaged(i), field5.PointerSparseManaged(i), field6.PointerSparseManaged(i), field7.PointerSparseManaged(i), field8.PointerSparseManaged(i), field9.PointerSparseManaged(i), field10.PointerSparseManaged(i), field11.PointerSparseManaged(i), field12.PointerSparseManaged(i), field13.PointerSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseSharedManaged(i), field1.PointerSparseSharedManaged(i), field2.PointerSparseSharedManaged(i), field3.PointerSparseSharedManaged(i), field4.PointerSparseSharedManaged(i), field5.PointerSparseSharedManaged(i), field6.PointerSparseSharedManaged(i), field7.PointerSparseSharedManaged(i), field8.PointerSparseSharedManaged(i), field9.PointerSparseSharedManaged(i), field10.PointerSparseSharedManaged(i), field11.PointerSparseSharedManaged(i), field12.PointerSparseSharedManaged(i), field13.PointerSparseSharedManaged(i));
+        }
     }
 
     /// <summary>
@@ -185,15 +811,93 @@ public static void Each<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8); byte* pointer9 = (byte*)it.GetPointer<T9>(9); byte* pointer10 = (byte*)it.GetPointer<T10>(10); byte* pointer11 = (byte*)it.GetPointer<T11>(11); byte* pointer12 = (byte*)it.GetPointer<T12>(12); byte* pointer13 = (byte*)it.GetPointer<T13>(13);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8); int step9 = it.Step<T9>(9); int step10 = it.Step<T10>(10); int step11 = it.Step<T11>(11); int step12 = it.Step<T12>(12); int step13 = it.Step<T13>(13);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8); FieldData<T9> field9 = it.GetFieldData<T9>(9); FieldData<T10> field10 = it.GetFieldData<T10>(10); FieldData<T11> field11 = it.GetFieldData<T11>(11); FieldData<T12> field12 = it.GetFieldData<T12>(12); FieldData<T13> field13 = it.GetFieldData<T13>(13);
+        IterationTechnique flags = it.GetIterationTechnique(14);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8], pointer9 = &pointer9[step9], pointer10 = &pointer10[step10], pointer11 = &pointer11[step11], pointer12 = &pointer12[step12], pointer13 = &pointer13[step13])
-            callback(it, i, (T0*)pointer0, (T1*)pointer1, (T2*)pointer2, (T3*)pointer3, (T4*)pointer4, (T5*)pointer5, (T6*)pointer6, (T7*)pointer7, (T8*)pointer8, (T9*)pointer9, (T10*)pointer10, (T11*)pointer11, (T12*)pointer12, (T13*)pointer13);
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>() || RuntimeHelpers.IsReferenceOrContainsReferences<T9>() || RuntimeHelpers.IsReferenceOrContainsReferences<T10>() || RuntimeHelpers.IsReferenceOrContainsReferences<T11>() || RuntimeHelpers.IsReferenceOrContainsReferences<T12>() || RuntimeHelpers.IsReferenceOrContainsReferences<T13>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerUnmanaged(i), field1.PointerUnmanaged(i), field2.PointerUnmanaged(i), field3.PointerUnmanaged(i), field4.PointerUnmanaged(i), field5.PointerUnmanaged(i), field6.PointerUnmanaged(i), field7.PointerUnmanaged(i), field8.PointerUnmanaged(i), field9.PointerUnmanaged(i), field10.PointerUnmanaged(i), field11.PointerUnmanaged(i), field12.PointerUnmanaged(i), field13.PointerUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSharedUnmanaged(i), field1.PointerSharedUnmanaged(i), field2.PointerSharedUnmanaged(i), field3.PointerSharedUnmanaged(i), field4.PointerSharedUnmanaged(i), field5.PointerSharedUnmanaged(i), field6.PointerSharedUnmanaged(i), field7.PointerSharedUnmanaged(i), field8.PointerSharedUnmanaged(i), field9.PointerSharedUnmanaged(i), field10.PointerSharedUnmanaged(i), field11.PointerSharedUnmanaged(i), field12.PointerSharedUnmanaged(i), field13.PointerSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSparseUnmanaged(i), field1.PointerSparseUnmanaged(i), field2.PointerSparseUnmanaged(i), field3.PointerSparseUnmanaged(i), field4.PointerSparseUnmanaged(i), field5.PointerSparseUnmanaged(i), field6.PointerSparseUnmanaged(i), field7.PointerSparseUnmanaged(i), field8.PointerSparseUnmanaged(i), field9.PointerSparseUnmanaged(i), field10.PointerSparseUnmanaged(i), field11.PointerSparseUnmanaged(i), field12.PointerSparseUnmanaged(i), field13.PointerSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSparseSharedUnmanaged(i), field1.PointerSparseSharedUnmanaged(i), field2.PointerSparseSharedUnmanaged(i), field3.PointerSparseSharedUnmanaged(i), field4.PointerSparseSharedUnmanaged(i), field5.PointerSparseSharedUnmanaged(i), field6.PointerSparseSharedUnmanaged(i), field7.PointerSparseSharedUnmanaged(i), field8.PointerSparseSharedUnmanaged(i), field9.PointerSparseSharedUnmanaged(i), field10.PointerSparseSharedUnmanaged(i), field11.PointerSparseSharedUnmanaged(i), field12.PointerSparseSharedUnmanaged(i), field13.PointerSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerManaged(i), field1.PointerManaged(i), field2.PointerManaged(i), field3.PointerManaged(i), field4.PointerManaged(i), field5.PointerManaged(i), field6.PointerManaged(i), field7.PointerManaged(i), field8.PointerManaged(i), field9.PointerManaged(i), field10.PointerManaged(i), field11.PointerManaged(i), field12.PointerManaged(i), field13.PointerManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSharedManaged(i), field1.PointerSharedManaged(i), field2.PointerSharedManaged(i), field3.PointerSharedManaged(i), field4.PointerSharedManaged(i), field5.PointerSharedManaged(i), field6.PointerSharedManaged(i), field7.PointerSharedManaged(i), field8.PointerSharedManaged(i), field9.PointerSharedManaged(i), field10.PointerSharedManaged(i), field11.PointerSharedManaged(i), field12.PointerSharedManaged(i), field13.PointerSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSparseManaged(i), field1.PointerSparseManaged(i), field2.PointerSparseManaged(i), field3.PointerSparseManaged(i), field4.PointerSparseManaged(i), field5.PointerSparseManaged(i), field6.PointerSparseManaged(i), field7.PointerSparseManaged(i), field8.PointerSparseManaged(i), field9.PointerSparseManaged(i), field10.PointerSparseManaged(i), field11.PointerSparseManaged(i), field12.PointerSparseManaged(i), field13.PointerSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSparseSharedManaged(i), field1.PointerSparseSharedManaged(i), field2.PointerSparseSharedManaged(i), field3.PointerSparseSharedManaged(i), field4.PointerSparseSharedManaged(i), field5.PointerSparseSharedManaged(i), field6.PointerSparseSharedManaged(i), field7.PointerSparseSharedManaged(i), field8.PointerSparseSharedManaged(i), field9.PointerSparseSharedManaged(i), field10.PointerSparseSharedManaged(i), field11.PointerSparseSharedManaged(i), field12.PointerSparseSharedManaged(i), field13.PointerSparseSharedManaged(i));
+        }
     }
 
     /// <summary>
@@ -206,15 +910,93 @@ public static void Each<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8); byte* pointer9 = (byte*)it.GetPointer<T9>(9); byte* pointer10 = (byte*)it.GetPointer<T10>(10); byte* pointer11 = (byte*)it.GetPointer<T11>(11); byte* pointer12 = (byte*)it.GetPointer<T12>(12); byte* pointer13 = (byte*)it.GetPointer<T13>(13);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8); int step9 = it.Step<T9>(9); int step10 = it.Step<T10>(10); int step11 = it.Step<T11>(11); int step12 = it.Step<T12>(12); int step13 = it.Step<T13>(13);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8); FieldData<T9> field9 = it.GetFieldData<T9>(9); FieldData<T10> field10 = it.GetFieldData<T10>(10); FieldData<T11> field11 = it.GetFieldData<T11>(11); FieldData<T12> field12 = it.GetFieldData<T12>(12); FieldData<T13> field13 = it.GetFieldData<T13>(13);
+        IterationTechnique flags = it.GetIterationTechnique(14);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8], pointer9 = &pointer9[step9], pointer10 = &pointer10[step10], pointer11 = &pointer11[step11], pointer12 = &pointer12[step12], pointer13 = &pointer13[step13])
-            callback((T0*)pointer0, (T1*)pointer1, (T2*)pointer2, (T3*)pointer3, (T4*)pointer4, (T5*)pointer5, (T6*)pointer6, (T7*)pointer7, (T8*)pointer8, (T9*)pointer9, (T10*)pointer10, (T11*)pointer11, (T12*)pointer12, (T13*)pointer13);
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>() || RuntimeHelpers.IsReferenceOrContainsReferences<T9>() || RuntimeHelpers.IsReferenceOrContainsReferences<T10>() || RuntimeHelpers.IsReferenceOrContainsReferences<T11>() || RuntimeHelpers.IsReferenceOrContainsReferences<T12>() || RuntimeHelpers.IsReferenceOrContainsReferences<T13>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerUnmanaged(i), field1.PointerUnmanaged(i), field2.PointerUnmanaged(i), field3.PointerUnmanaged(i), field4.PointerUnmanaged(i), field5.PointerUnmanaged(i), field6.PointerUnmanaged(i), field7.PointerUnmanaged(i), field8.PointerUnmanaged(i), field9.PointerUnmanaged(i), field10.PointerUnmanaged(i), field11.PointerUnmanaged(i), field12.PointerUnmanaged(i), field13.PointerUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSharedUnmanaged(i), field1.PointerSharedUnmanaged(i), field2.PointerSharedUnmanaged(i), field3.PointerSharedUnmanaged(i), field4.PointerSharedUnmanaged(i), field5.PointerSharedUnmanaged(i), field6.PointerSharedUnmanaged(i), field7.PointerSharedUnmanaged(i), field8.PointerSharedUnmanaged(i), field9.PointerSharedUnmanaged(i), field10.PointerSharedUnmanaged(i), field11.PointerSharedUnmanaged(i), field12.PointerSharedUnmanaged(i), field13.PointerSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSparseUnmanaged(i), field1.PointerSparseUnmanaged(i), field2.PointerSparseUnmanaged(i), field3.PointerSparseUnmanaged(i), field4.PointerSparseUnmanaged(i), field5.PointerSparseUnmanaged(i), field6.PointerSparseUnmanaged(i), field7.PointerSparseUnmanaged(i), field8.PointerSparseUnmanaged(i), field9.PointerSparseUnmanaged(i), field10.PointerSparseUnmanaged(i), field11.PointerSparseUnmanaged(i), field12.PointerSparseUnmanaged(i), field13.PointerSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSparseSharedUnmanaged(i), field1.PointerSparseSharedUnmanaged(i), field2.PointerSparseSharedUnmanaged(i), field3.PointerSparseSharedUnmanaged(i), field4.PointerSparseSharedUnmanaged(i), field5.PointerSparseSharedUnmanaged(i), field6.PointerSparseSharedUnmanaged(i), field7.PointerSparseSharedUnmanaged(i), field8.PointerSparseSharedUnmanaged(i), field9.PointerSparseSharedUnmanaged(i), field10.PointerSparseSharedUnmanaged(i), field11.PointerSparseSharedUnmanaged(i), field12.PointerSparseSharedUnmanaged(i), field13.PointerSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerManaged(i), field1.PointerManaged(i), field2.PointerManaged(i), field3.PointerManaged(i), field4.PointerManaged(i), field5.PointerManaged(i), field6.PointerManaged(i), field7.PointerManaged(i), field8.PointerManaged(i), field9.PointerManaged(i), field10.PointerManaged(i), field11.PointerManaged(i), field12.PointerManaged(i), field13.PointerManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSharedManaged(i), field1.PointerSharedManaged(i), field2.PointerSharedManaged(i), field3.PointerSharedManaged(i), field4.PointerSharedManaged(i), field5.PointerSharedManaged(i), field6.PointerSharedManaged(i), field7.PointerSharedManaged(i), field8.PointerSharedManaged(i), field9.PointerSharedManaged(i), field10.PointerSharedManaged(i), field11.PointerSharedManaged(i), field12.PointerSharedManaged(i), field13.PointerSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSparseManaged(i), field1.PointerSparseManaged(i), field2.PointerSparseManaged(i), field3.PointerSparseManaged(i), field4.PointerSparseManaged(i), field5.PointerSparseManaged(i), field6.PointerSparseManaged(i), field7.PointerSparseManaged(i), field8.PointerSparseManaged(i), field9.PointerSparseManaged(i), field10.PointerSparseManaged(i), field11.PointerSparseManaged(i), field12.PointerSparseManaged(i), field13.PointerSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSparseSharedManaged(i), field1.PointerSparseSharedManaged(i), field2.PointerSparseSharedManaged(i), field3.PointerSparseSharedManaged(i), field4.PointerSparseSharedManaged(i), field5.PointerSparseSharedManaged(i), field6.PointerSparseSharedManaged(i), field7.PointerSparseSharedManaged(i), field8.PointerSparseSharedManaged(i), field9.PointerSparseSharedManaged(i), field10.PointerSparseSharedManaged(i), field11.PointerSparseSharedManaged(i), field12.PointerSparseSharedManaged(i), field13.PointerSparseSharedManaged(i));
+        }
     }
 
     /// <summary>
@@ -227,15 +1009,93 @@ public static void Each<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T
     {
         int count = it.Handle->count; Ecs.Assert(it.Handle->count > 0, "No entities returned, use Iter() or Each() without the entity argument instead.");
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8); byte* pointer9 = (byte*)it.GetPointer<T9>(9); byte* pointer10 = (byte*)it.GetPointer<T10>(10); byte* pointer11 = (byte*)it.GetPointer<T11>(11); byte* pointer12 = (byte*)it.GetPointer<T12>(12); byte* pointer13 = (byte*)it.GetPointer<T13>(13);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8); int step9 = it.Step<T9>(9); int step10 = it.Step<T10>(10); int step11 = it.Step<T11>(11); int step12 = it.Step<T12>(12); int step13 = it.Step<T13>(13);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8); FieldData<T9> field9 = it.GetFieldData<T9>(9); FieldData<T10> field10 = it.GetFieldData<T10>(10); FieldData<T11> field11 = it.GetFieldData<T11>(11); FieldData<T12> field12 = it.GetFieldData<T12>(12); FieldData<T13> field13 = it.GetFieldData<T13>(13);
+        IterationTechnique flags = it.GetIterationTechnique(14);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8], pointer9 = &pointer9[step9], pointer10 = &pointer10[step10], pointer11 = &pointer11[step11], pointer12 = &pointer12[step12], pointer13 = &pointer13[step13])
-            callback(new Entity(it.Handle->world, it.Handle->entities[i]), (T0*)pointer0, (T1*)pointer1, (T2*)pointer2, (T3*)pointer3, (T4*)pointer4, (T5*)pointer5, (T6*)pointer6, (T7*)pointer7, (T8*)pointer8, (T9*)pointer9, (T10*)pointer10, (T11*)pointer11, (T12*)pointer12, (T13*)pointer13);
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>() || RuntimeHelpers.IsReferenceOrContainsReferences<T9>() || RuntimeHelpers.IsReferenceOrContainsReferences<T10>() || RuntimeHelpers.IsReferenceOrContainsReferences<T11>() || RuntimeHelpers.IsReferenceOrContainsReferences<T12>() || RuntimeHelpers.IsReferenceOrContainsReferences<T13>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerUnmanaged(i), field1.PointerUnmanaged(i), field2.PointerUnmanaged(i), field3.PointerUnmanaged(i), field4.PointerUnmanaged(i), field5.PointerUnmanaged(i), field6.PointerUnmanaged(i), field7.PointerUnmanaged(i), field8.PointerUnmanaged(i), field9.PointerUnmanaged(i), field10.PointerUnmanaged(i), field11.PointerUnmanaged(i), field12.PointerUnmanaged(i), field13.PointerUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSharedUnmanaged(i), field1.PointerSharedUnmanaged(i), field2.PointerSharedUnmanaged(i), field3.PointerSharedUnmanaged(i), field4.PointerSharedUnmanaged(i), field5.PointerSharedUnmanaged(i), field6.PointerSharedUnmanaged(i), field7.PointerSharedUnmanaged(i), field8.PointerSharedUnmanaged(i), field9.PointerSharedUnmanaged(i), field10.PointerSharedUnmanaged(i), field11.PointerSharedUnmanaged(i), field12.PointerSharedUnmanaged(i), field13.PointerSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseUnmanaged(i), field1.PointerSparseUnmanaged(i), field2.PointerSparseUnmanaged(i), field3.PointerSparseUnmanaged(i), field4.PointerSparseUnmanaged(i), field5.PointerSparseUnmanaged(i), field6.PointerSparseUnmanaged(i), field7.PointerSparseUnmanaged(i), field8.PointerSparseUnmanaged(i), field9.PointerSparseUnmanaged(i), field10.PointerSparseUnmanaged(i), field11.PointerSparseUnmanaged(i), field12.PointerSparseUnmanaged(i), field13.PointerSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseSharedUnmanaged(i), field1.PointerSparseSharedUnmanaged(i), field2.PointerSparseSharedUnmanaged(i), field3.PointerSparseSharedUnmanaged(i), field4.PointerSparseSharedUnmanaged(i), field5.PointerSparseSharedUnmanaged(i), field6.PointerSparseSharedUnmanaged(i), field7.PointerSparseSharedUnmanaged(i), field8.PointerSparseSharedUnmanaged(i), field9.PointerSparseSharedUnmanaged(i), field10.PointerSparseSharedUnmanaged(i), field11.PointerSparseSharedUnmanaged(i), field12.PointerSparseSharedUnmanaged(i), field13.PointerSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerManaged(i), field1.PointerManaged(i), field2.PointerManaged(i), field3.PointerManaged(i), field4.PointerManaged(i), field5.PointerManaged(i), field6.PointerManaged(i), field7.PointerManaged(i), field8.PointerManaged(i), field9.PointerManaged(i), field10.PointerManaged(i), field11.PointerManaged(i), field12.PointerManaged(i), field13.PointerManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSharedManaged(i), field1.PointerSharedManaged(i), field2.PointerSharedManaged(i), field3.PointerSharedManaged(i), field4.PointerSharedManaged(i), field5.PointerSharedManaged(i), field6.PointerSharedManaged(i), field7.PointerSharedManaged(i), field8.PointerSharedManaged(i), field9.PointerSharedManaged(i), field10.PointerSharedManaged(i), field11.PointerSharedManaged(i), field12.PointerSharedManaged(i), field13.PointerSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseManaged(i), field1.PointerSparseManaged(i), field2.PointerSparseManaged(i), field3.PointerSparseManaged(i), field4.PointerSparseManaged(i), field5.PointerSparseManaged(i), field6.PointerSparseManaged(i), field7.PointerSparseManaged(i), field8.PointerSparseManaged(i), field9.PointerSparseManaged(i), field10.PointerSparseManaged(i), field11.PointerSparseManaged(i), field12.PointerSparseManaged(i), field13.PointerSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseSharedManaged(i), field1.PointerSparseSharedManaged(i), field2.PointerSparseSharedManaged(i), field3.PointerSparseSharedManaged(i), field4.PointerSparseSharedManaged(i), field5.PointerSparseSharedManaged(i), field6.PointerSparseSharedManaged(i), field7.PointerSparseSharedManaged(i), field8.PointerSparseSharedManaged(i), field9.PointerSparseSharedManaged(i), field10.PointerSparseSharedManaged(i), field11.PointerSparseSharedManaged(i), field12.PointerSparseSharedManaged(i), field13.PointerSparseSharedManaged(i));
+        }
     }
 
     /// <summary>
@@ -248,14 +1108,92 @@ public static void Each<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8); byte* pointer9 = (byte*)it.GetPointer<T9>(9); byte* pointer10 = (byte*)it.GetPointer<T10>(10); byte* pointer11 = (byte*)it.GetPointer<T11>(11); byte* pointer12 = (byte*)it.GetPointer<T12>(12); byte* pointer13 = (byte*)it.GetPointer<T13>(13);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8); int step9 = it.Step<T9>(9); int step10 = it.Step<T10>(10); int step11 = it.Step<T11>(11); int step12 = it.Step<T12>(12); int step13 = it.Step<T13>(13);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8); FieldData<T9> field9 = it.GetFieldData<T9>(9); FieldData<T10> field10 = it.GetFieldData<T10>(10); FieldData<T11> field11 = it.GetFieldData<T11>(11); FieldData<T12> field12 = it.GetFieldData<T12>(12); FieldData<T13> field13 = it.GetFieldData<T13>(13);
+        IterationTechnique flags = it.GetIterationTechnique(14);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8], pointer9 = &pointer9[step9], pointer10 = &pointer10[step10], pointer11 = &pointer11[step11], pointer12 = &pointer12[step12], pointer13 = &pointer13[step13])
-            callback(it, i, (T0*)pointer0, (T1*)pointer1, (T2*)pointer2, (T3*)pointer3, (T4*)pointer4, (T5*)pointer5, (T6*)pointer6, (T7*)pointer7, (T8*)pointer8, (T9*)pointer9, (T10*)pointer10, (T11*)pointer11, (T12*)pointer12, (T13*)pointer13);
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>() || RuntimeHelpers.IsReferenceOrContainsReferences<T9>() || RuntimeHelpers.IsReferenceOrContainsReferences<T10>() || RuntimeHelpers.IsReferenceOrContainsReferences<T11>() || RuntimeHelpers.IsReferenceOrContainsReferences<T12>() || RuntimeHelpers.IsReferenceOrContainsReferences<T13>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerUnmanaged(i), field1.PointerUnmanaged(i), field2.PointerUnmanaged(i), field3.PointerUnmanaged(i), field4.PointerUnmanaged(i), field5.PointerUnmanaged(i), field6.PointerUnmanaged(i), field7.PointerUnmanaged(i), field8.PointerUnmanaged(i), field9.PointerUnmanaged(i), field10.PointerUnmanaged(i), field11.PointerUnmanaged(i), field12.PointerUnmanaged(i), field13.PointerUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSharedUnmanaged(i), field1.PointerSharedUnmanaged(i), field2.PointerSharedUnmanaged(i), field3.PointerSharedUnmanaged(i), field4.PointerSharedUnmanaged(i), field5.PointerSharedUnmanaged(i), field6.PointerSharedUnmanaged(i), field7.PointerSharedUnmanaged(i), field8.PointerSharedUnmanaged(i), field9.PointerSharedUnmanaged(i), field10.PointerSharedUnmanaged(i), field11.PointerSharedUnmanaged(i), field12.PointerSharedUnmanaged(i), field13.PointerSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSparseUnmanaged(i), field1.PointerSparseUnmanaged(i), field2.PointerSparseUnmanaged(i), field3.PointerSparseUnmanaged(i), field4.PointerSparseUnmanaged(i), field5.PointerSparseUnmanaged(i), field6.PointerSparseUnmanaged(i), field7.PointerSparseUnmanaged(i), field8.PointerSparseUnmanaged(i), field9.PointerSparseUnmanaged(i), field10.PointerSparseUnmanaged(i), field11.PointerSparseUnmanaged(i), field12.PointerSparseUnmanaged(i), field13.PointerSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSparseSharedUnmanaged(i), field1.PointerSparseSharedUnmanaged(i), field2.PointerSparseSharedUnmanaged(i), field3.PointerSparseSharedUnmanaged(i), field4.PointerSparseSharedUnmanaged(i), field5.PointerSparseSharedUnmanaged(i), field6.PointerSparseSharedUnmanaged(i), field7.PointerSparseSharedUnmanaged(i), field8.PointerSparseSharedUnmanaged(i), field9.PointerSparseSharedUnmanaged(i), field10.PointerSparseSharedUnmanaged(i), field11.PointerSparseSharedUnmanaged(i), field12.PointerSparseSharedUnmanaged(i), field13.PointerSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerManaged(i), field1.PointerManaged(i), field2.PointerManaged(i), field3.PointerManaged(i), field4.PointerManaged(i), field5.PointerManaged(i), field6.PointerManaged(i), field7.PointerManaged(i), field8.PointerManaged(i), field9.PointerManaged(i), field10.PointerManaged(i), field11.PointerManaged(i), field12.PointerManaged(i), field13.PointerManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSharedManaged(i), field1.PointerSharedManaged(i), field2.PointerSharedManaged(i), field3.PointerSharedManaged(i), field4.PointerSharedManaged(i), field5.PointerSharedManaged(i), field6.PointerSharedManaged(i), field7.PointerSharedManaged(i), field8.PointerSharedManaged(i), field9.PointerSharedManaged(i), field10.PointerSharedManaged(i), field11.PointerSharedManaged(i), field12.PointerSharedManaged(i), field13.PointerSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSparseManaged(i), field1.PointerSparseManaged(i), field2.PointerSparseManaged(i), field3.PointerSparseManaged(i), field4.PointerSparseManaged(i), field5.PointerSparseManaged(i), field6.PointerSparseManaged(i), field7.PointerSparseManaged(i), field8.PointerSparseManaged(i), field9.PointerSparseManaged(i), field10.PointerSparseManaged(i), field11.PointerSparseManaged(i), field12.PointerSparseManaged(i), field13.PointerSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSparseSharedManaged(i), field1.PointerSparseSharedManaged(i), field2.PointerSparseSharedManaged(i), field3.PointerSparseSharedManaged(i), field4.PointerSparseSharedManaged(i), field5.PointerSparseSharedManaged(i), field6.PointerSparseSharedManaged(i), field7.PointerSparseSharedManaged(i), field8.PointerSparseSharedManaged(i), field9.PointerSparseSharedManaged(i), field10.PointerSparseSharedManaged(i), field11.PointerSparseSharedManaged(i), field12.PointerSparseSharedManaged(i), field13.PointerSparseSharedManaged(i));
+        }
     }
 }
\ No newline at end of file
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/Invoker/Each/Iterator/T15.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/Invoker/Each/Iterator/T15.g.cs
index 34029ada..75955ca4 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/Invoker/Each/Iterator/T15.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/Invoker/Each/Iterator/T15.g.cs
@@ -1,5 +1,7 @@
 // Each/Iterator/T15.g.cs
 // File was auto-generated by /_/src/Flecs.NET.Codegen/Generators/Invoker.cs
+using System;
+using System.Runtime.CompilerServices;
 using Flecs.NET.Utilities;
 using static Flecs.NET.Bindings.flecs;
 
@@ -17,15 +19,93 @@ public static void Each<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8); byte* pointer9 = (byte*)it.GetPointer<T9>(9); byte* pointer10 = (byte*)it.GetPointer<T10>(10); byte* pointer11 = (byte*)it.GetPointer<T11>(11); byte* pointer12 = (byte*)it.GetPointer<T12>(12); byte* pointer13 = (byte*)it.GetPointer<T13>(13); byte* pointer14 = (byte*)it.GetPointer<T14>(14);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8); int step9 = it.Step<T9>(9); int step10 = it.Step<T10>(10); int step11 = it.Step<T11>(11); int step12 = it.Step<T12>(12); int step13 = it.Step<T13>(13); int step14 = it.Step<T14>(14);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8); FieldData<T9> field9 = it.GetFieldData<T9>(9); FieldData<T10> field10 = it.GetFieldData<T10>(10); FieldData<T11> field11 = it.GetFieldData<T11>(11); FieldData<T12> field12 = it.GetFieldData<T12>(12); FieldData<T13> field13 = it.GetFieldData<T13>(13); FieldData<T14> field14 = it.GetFieldData<T14>(14);
+        IterationTechnique flags = it.GetIterationTechnique(15);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8], pointer9 = &pointer9[step9], pointer10 = &pointer10[step10], pointer11 = &pointer11[step11], pointer12 = &pointer12[step12], pointer13 = &pointer13[step13], pointer14 = &pointer14[step14])
-            callback(ref Managed.GetTypeRef<T0>(pointer0), ref Managed.GetTypeRef<T1>(pointer1), ref Managed.GetTypeRef<T2>(pointer2), ref Managed.GetTypeRef<T3>(pointer3), ref Managed.GetTypeRef<T4>(pointer4), ref Managed.GetTypeRef<T5>(pointer5), ref Managed.GetTypeRef<T6>(pointer6), ref Managed.GetTypeRef<T7>(pointer7), ref Managed.GetTypeRef<T8>(pointer8), ref Managed.GetTypeRef<T9>(pointer9), ref Managed.GetTypeRef<T10>(pointer10), ref Managed.GetTypeRef<T11>(pointer11), ref Managed.GetTypeRef<T12>(pointer12), ref Managed.GetTypeRef<T13>(pointer13), ref Managed.GetTypeRef<T14>(pointer14));
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>() || RuntimeHelpers.IsReferenceOrContainsReferences<T9>() || RuntimeHelpers.IsReferenceOrContainsReferences<T10>() || RuntimeHelpers.IsReferenceOrContainsReferences<T11>() || RuntimeHelpers.IsReferenceOrContainsReferences<T12>() || RuntimeHelpers.IsReferenceOrContainsReferences<T13>() || RuntimeHelpers.IsReferenceOrContainsReferences<T14>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefUnmanaged(i), ref field1.RefUnmanaged(i), ref field2.RefUnmanaged(i), ref field3.RefUnmanaged(i), ref field4.RefUnmanaged(i), ref field5.RefUnmanaged(i), ref field6.RefUnmanaged(i), ref field7.RefUnmanaged(i), ref field8.RefUnmanaged(i), ref field9.RefUnmanaged(i), ref field10.RefUnmanaged(i), ref field11.RefUnmanaged(i), ref field12.RefUnmanaged(i), ref field13.RefUnmanaged(i), ref field14.RefUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSharedUnmanaged(i), ref field1.RefSharedUnmanaged(i), ref field2.RefSharedUnmanaged(i), ref field3.RefSharedUnmanaged(i), ref field4.RefSharedUnmanaged(i), ref field5.RefSharedUnmanaged(i), ref field6.RefSharedUnmanaged(i), ref field7.RefSharedUnmanaged(i), ref field8.RefSharedUnmanaged(i), ref field9.RefSharedUnmanaged(i), ref field10.RefSharedUnmanaged(i), ref field11.RefSharedUnmanaged(i), ref field12.RefSharedUnmanaged(i), ref field13.RefSharedUnmanaged(i), ref field14.RefSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSparseUnmanaged(i), ref field1.RefSparseUnmanaged(i), ref field2.RefSparseUnmanaged(i), ref field3.RefSparseUnmanaged(i), ref field4.RefSparseUnmanaged(i), ref field5.RefSparseUnmanaged(i), ref field6.RefSparseUnmanaged(i), ref field7.RefSparseUnmanaged(i), ref field8.RefSparseUnmanaged(i), ref field9.RefSparseUnmanaged(i), ref field10.RefSparseUnmanaged(i), ref field11.RefSparseUnmanaged(i), ref field12.RefSparseUnmanaged(i), ref field13.RefSparseUnmanaged(i), ref field14.RefSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSparseSharedUnmanaged(i), ref field1.RefSparseSharedUnmanaged(i), ref field2.RefSparseSharedUnmanaged(i), ref field3.RefSparseSharedUnmanaged(i), ref field4.RefSparseSharedUnmanaged(i), ref field5.RefSparseSharedUnmanaged(i), ref field6.RefSparseSharedUnmanaged(i), ref field7.RefSparseSharedUnmanaged(i), ref field8.RefSparseSharedUnmanaged(i), ref field9.RefSparseSharedUnmanaged(i), ref field10.RefSparseSharedUnmanaged(i), ref field11.RefSparseSharedUnmanaged(i), ref field12.RefSparseSharedUnmanaged(i), ref field13.RefSparseSharedUnmanaged(i), ref field14.RefSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefManaged(i), ref field1.RefManaged(i), ref field2.RefManaged(i), ref field3.RefManaged(i), ref field4.RefManaged(i), ref field5.RefManaged(i), ref field6.RefManaged(i), ref field7.RefManaged(i), ref field8.RefManaged(i), ref field9.RefManaged(i), ref field10.RefManaged(i), ref field11.RefManaged(i), ref field12.RefManaged(i), ref field13.RefManaged(i), ref field14.RefManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSharedManaged(i), ref field1.RefSharedManaged(i), ref field2.RefSharedManaged(i), ref field3.RefSharedManaged(i), ref field4.RefSharedManaged(i), ref field5.RefSharedManaged(i), ref field6.RefSharedManaged(i), ref field7.RefSharedManaged(i), ref field8.RefSharedManaged(i), ref field9.RefSharedManaged(i), ref field10.RefSharedManaged(i), ref field11.RefSharedManaged(i), ref field12.RefSharedManaged(i), ref field13.RefSharedManaged(i), ref field14.RefSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSparseManaged(i), ref field1.RefSparseManaged(i), ref field2.RefSparseManaged(i), ref field3.RefSparseManaged(i), ref field4.RefSparseManaged(i), ref field5.RefSparseManaged(i), ref field6.RefSparseManaged(i), ref field7.RefSparseManaged(i), ref field8.RefSparseManaged(i), ref field9.RefSparseManaged(i), ref field10.RefSparseManaged(i), ref field11.RefSparseManaged(i), ref field12.RefSparseManaged(i), ref field13.RefSparseManaged(i), ref field14.RefSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSparseSharedManaged(i), ref field1.RefSparseSharedManaged(i), ref field2.RefSparseSharedManaged(i), ref field3.RefSparseSharedManaged(i), ref field4.RefSparseSharedManaged(i), ref field5.RefSparseSharedManaged(i), ref field6.RefSparseSharedManaged(i), ref field7.RefSparseSharedManaged(i), ref field8.RefSparseSharedManaged(i), ref field9.RefSparseSharedManaged(i), ref field10.RefSparseSharedManaged(i), ref field11.RefSparseSharedManaged(i), ref field12.RefSparseSharedManaged(i), ref field13.RefSparseSharedManaged(i), ref field14.RefSparseSharedManaged(i));
+        }
     }
 
     /// <summary>
@@ -38,15 +118,93 @@ public static void Each<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T
     {
         int count = it.Handle->count; Ecs.Assert(it.Handle->count > 0, "No entities returned, use Iter() or Each() without the entity argument instead.");
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8); byte* pointer9 = (byte*)it.GetPointer<T9>(9); byte* pointer10 = (byte*)it.GetPointer<T10>(10); byte* pointer11 = (byte*)it.GetPointer<T11>(11); byte* pointer12 = (byte*)it.GetPointer<T12>(12); byte* pointer13 = (byte*)it.GetPointer<T13>(13); byte* pointer14 = (byte*)it.GetPointer<T14>(14);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8); int step9 = it.Step<T9>(9); int step10 = it.Step<T10>(10); int step11 = it.Step<T11>(11); int step12 = it.Step<T12>(12); int step13 = it.Step<T13>(13); int step14 = it.Step<T14>(14);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8); FieldData<T9> field9 = it.GetFieldData<T9>(9); FieldData<T10> field10 = it.GetFieldData<T10>(10); FieldData<T11> field11 = it.GetFieldData<T11>(11); FieldData<T12> field12 = it.GetFieldData<T12>(12); FieldData<T13> field13 = it.GetFieldData<T13>(13); FieldData<T14> field14 = it.GetFieldData<T14>(14);
+        IterationTechnique flags = it.GetIterationTechnique(15);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8], pointer9 = &pointer9[step9], pointer10 = &pointer10[step10], pointer11 = &pointer11[step11], pointer12 = &pointer12[step12], pointer13 = &pointer13[step13], pointer14 = &pointer14[step14])
-            callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref Managed.GetTypeRef<T0>(pointer0), ref Managed.GetTypeRef<T1>(pointer1), ref Managed.GetTypeRef<T2>(pointer2), ref Managed.GetTypeRef<T3>(pointer3), ref Managed.GetTypeRef<T4>(pointer4), ref Managed.GetTypeRef<T5>(pointer5), ref Managed.GetTypeRef<T6>(pointer6), ref Managed.GetTypeRef<T7>(pointer7), ref Managed.GetTypeRef<T8>(pointer8), ref Managed.GetTypeRef<T9>(pointer9), ref Managed.GetTypeRef<T10>(pointer10), ref Managed.GetTypeRef<T11>(pointer11), ref Managed.GetTypeRef<T12>(pointer12), ref Managed.GetTypeRef<T13>(pointer13), ref Managed.GetTypeRef<T14>(pointer14));
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>() || RuntimeHelpers.IsReferenceOrContainsReferences<T9>() || RuntimeHelpers.IsReferenceOrContainsReferences<T10>() || RuntimeHelpers.IsReferenceOrContainsReferences<T11>() || RuntimeHelpers.IsReferenceOrContainsReferences<T12>() || RuntimeHelpers.IsReferenceOrContainsReferences<T13>() || RuntimeHelpers.IsReferenceOrContainsReferences<T14>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefUnmanaged(i), ref field1.RefUnmanaged(i), ref field2.RefUnmanaged(i), ref field3.RefUnmanaged(i), ref field4.RefUnmanaged(i), ref field5.RefUnmanaged(i), ref field6.RefUnmanaged(i), ref field7.RefUnmanaged(i), ref field8.RefUnmanaged(i), ref field9.RefUnmanaged(i), ref field10.RefUnmanaged(i), ref field11.RefUnmanaged(i), ref field12.RefUnmanaged(i), ref field13.RefUnmanaged(i), ref field14.RefUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSharedUnmanaged(i), ref field1.RefSharedUnmanaged(i), ref field2.RefSharedUnmanaged(i), ref field3.RefSharedUnmanaged(i), ref field4.RefSharedUnmanaged(i), ref field5.RefSharedUnmanaged(i), ref field6.RefSharedUnmanaged(i), ref field7.RefSharedUnmanaged(i), ref field8.RefSharedUnmanaged(i), ref field9.RefSharedUnmanaged(i), ref field10.RefSharedUnmanaged(i), ref field11.RefSharedUnmanaged(i), ref field12.RefSharedUnmanaged(i), ref field13.RefSharedUnmanaged(i), ref field14.RefSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseUnmanaged(i), ref field1.RefSparseUnmanaged(i), ref field2.RefSparseUnmanaged(i), ref field3.RefSparseUnmanaged(i), ref field4.RefSparseUnmanaged(i), ref field5.RefSparseUnmanaged(i), ref field6.RefSparseUnmanaged(i), ref field7.RefSparseUnmanaged(i), ref field8.RefSparseUnmanaged(i), ref field9.RefSparseUnmanaged(i), ref field10.RefSparseUnmanaged(i), ref field11.RefSparseUnmanaged(i), ref field12.RefSparseUnmanaged(i), ref field13.RefSparseUnmanaged(i), ref field14.RefSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseSharedUnmanaged(i), ref field1.RefSparseSharedUnmanaged(i), ref field2.RefSparseSharedUnmanaged(i), ref field3.RefSparseSharedUnmanaged(i), ref field4.RefSparseSharedUnmanaged(i), ref field5.RefSparseSharedUnmanaged(i), ref field6.RefSparseSharedUnmanaged(i), ref field7.RefSparseSharedUnmanaged(i), ref field8.RefSparseSharedUnmanaged(i), ref field9.RefSparseSharedUnmanaged(i), ref field10.RefSparseSharedUnmanaged(i), ref field11.RefSparseSharedUnmanaged(i), ref field12.RefSparseSharedUnmanaged(i), ref field13.RefSparseSharedUnmanaged(i), ref field14.RefSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefManaged(i), ref field1.RefManaged(i), ref field2.RefManaged(i), ref field3.RefManaged(i), ref field4.RefManaged(i), ref field5.RefManaged(i), ref field6.RefManaged(i), ref field7.RefManaged(i), ref field8.RefManaged(i), ref field9.RefManaged(i), ref field10.RefManaged(i), ref field11.RefManaged(i), ref field12.RefManaged(i), ref field13.RefManaged(i), ref field14.RefManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSharedManaged(i), ref field1.RefSharedManaged(i), ref field2.RefSharedManaged(i), ref field3.RefSharedManaged(i), ref field4.RefSharedManaged(i), ref field5.RefSharedManaged(i), ref field6.RefSharedManaged(i), ref field7.RefSharedManaged(i), ref field8.RefSharedManaged(i), ref field9.RefSharedManaged(i), ref field10.RefSharedManaged(i), ref field11.RefSharedManaged(i), ref field12.RefSharedManaged(i), ref field13.RefSharedManaged(i), ref field14.RefSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseManaged(i), ref field1.RefSparseManaged(i), ref field2.RefSparseManaged(i), ref field3.RefSparseManaged(i), ref field4.RefSparseManaged(i), ref field5.RefSparseManaged(i), ref field6.RefSparseManaged(i), ref field7.RefSparseManaged(i), ref field8.RefSparseManaged(i), ref field9.RefSparseManaged(i), ref field10.RefSparseManaged(i), ref field11.RefSparseManaged(i), ref field12.RefSparseManaged(i), ref field13.RefSparseManaged(i), ref field14.RefSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseSharedManaged(i), ref field1.RefSparseSharedManaged(i), ref field2.RefSparseSharedManaged(i), ref field3.RefSparseSharedManaged(i), ref field4.RefSparseSharedManaged(i), ref field5.RefSparseSharedManaged(i), ref field6.RefSparseSharedManaged(i), ref field7.RefSparseSharedManaged(i), ref field8.RefSparseSharedManaged(i), ref field9.RefSparseSharedManaged(i), ref field10.RefSparseSharedManaged(i), ref field11.RefSparseSharedManaged(i), ref field12.RefSparseSharedManaged(i), ref field13.RefSparseSharedManaged(i), ref field14.RefSparseSharedManaged(i));
+        }
     }
 
     /// <summary>
@@ -59,15 +217,93 @@ public static void Each<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8); byte* pointer9 = (byte*)it.GetPointer<T9>(9); byte* pointer10 = (byte*)it.GetPointer<T10>(10); byte* pointer11 = (byte*)it.GetPointer<T11>(11); byte* pointer12 = (byte*)it.GetPointer<T12>(12); byte* pointer13 = (byte*)it.GetPointer<T13>(13); byte* pointer14 = (byte*)it.GetPointer<T14>(14);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8); int step9 = it.Step<T9>(9); int step10 = it.Step<T10>(10); int step11 = it.Step<T11>(11); int step12 = it.Step<T12>(12); int step13 = it.Step<T13>(13); int step14 = it.Step<T14>(14);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8); FieldData<T9> field9 = it.GetFieldData<T9>(9); FieldData<T10> field10 = it.GetFieldData<T10>(10); FieldData<T11> field11 = it.GetFieldData<T11>(11); FieldData<T12> field12 = it.GetFieldData<T12>(12); FieldData<T13> field13 = it.GetFieldData<T13>(13); FieldData<T14> field14 = it.GetFieldData<T14>(14);
+        IterationTechnique flags = it.GetIterationTechnique(15);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8], pointer9 = &pointer9[step9], pointer10 = &pointer10[step10], pointer11 = &pointer11[step11], pointer12 = &pointer12[step12], pointer13 = &pointer13[step13], pointer14 = &pointer14[step14])
-            callback(it, i, ref Managed.GetTypeRef<T0>(pointer0), ref Managed.GetTypeRef<T1>(pointer1), ref Managed.GetTypeRef<T2>(pointer2), ref Managed.GetTypeRef<T3>(pointer3), ref Managed.GetTypeRef<T4>(pointer4), ref Managed.GetTypeRef<T5>(pointer5), ref Managed.GetTypeRef<T6>(pointer6), ref Managed.GetTypeRef<T7>(pointer7), ref Managed.GetTypeRef<T8>(pointer8), ref Managed.GetTypeRef<T9>(pointer9), ref Managed.GetTypeRef<T10>(pointer10), ref Managed.GetTypeRef<T11>(pointer11), ref Managed.GetTypeRef<T12>(pointer12), ref Managed.GetTypeRef<T13>(pointer13), ref Managed.GetTypeRef<T14>(pointer14));
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>() || RuntimeHelpers.IsReferenceOrContainsReferences<T9>() || RuntimeHelpers.IsReferenceOrContainsReferences<T10>() || RuntimeHelpers.IsReferenceOrContainsReferences<T11>() || RuntimeHelpers.IsReferenceOrContainsReferences<T12>() || RuntimeHelpers.IsReferenceOrContainsReferences<T13>() || RuntimeHelpers.IsReferenceOrContainsReferences<T14>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefUnmanaged(i), ref field1.RefUnmanaged(i), ref field2.RefUnmanaged(i), ref field3.RefUnmanaged(i), ref field4.RefUnmanaged(i), ref field5.RefUnmanaged(i), ref field6.RefUnmanaged(i), ref field7.RefUnmanaged(i), ref field8.RefUnmanaged(i), ref field9.RefUnmanaged(i), ref field10.RefUnmanaged(i), ref field11.RefUnmanaged(i), ref field12.RefUnmanaged(i), ref field13.RefUnmanaged(i), ref field14.RefUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSharedUnmanaged(i), ref field1.RefSharedUnmanaged(i), ref field2.RefSharedUnmanaged(i), ref field3.RefSharedUnmanaged(i), ref field4.RefSharedUnmanaged(i), ref field5.RefSharedUnmanaged(i), ref field6.RefSharedUnmanaged(i), ref field7.RefSharedUnmanaged(i), ref field8.RefSharedUnmanaged(i), ref field9.RefSharedUnmanaged(i), ref field10.RefSharedUnmanaged(i), ref field11.RefSharedUnmanaged(i), ref field12.RefSharedUnmanaged(i), ref field13.RefSharedUnmanaged(i), ref field14.RefSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSparseUnmanaged(i), ref field1.RefSparseUnmanaged(i), ref field2.RefSparseUnmanaged(i), ref field3.RefSparseUnmanaged(i), ref field4.RefSparseUnmanaged(i), ref field5.RefSparseUnmanaged(i), ref field6.RefSparseUnmanaged(i), ref field7.RefSparseUnmanaged(i), ref field8.RefSparseUnmanaged(i), ref field9.RefSparseUnmanaged(i), ref field10.RefSparseUnmanaged(i), ref field11.RefSparseUnmanaged(i), ref field12.RefSparseUnmanaged(i), ref field13.RefSparseUnmanaged(i), ref field14.RefSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSparseSharedUnmanaged(i), ref field1.RefSparseSharedUnmanaged(i), ref field2.RefSparseSharedUnmanaged(i), ref field3.RefSparseSharedUnmanaged(i), ref field4.RefSparseSharedUnmanaged(i), ref field5.RefSparseSharedUnmanaged(i), ref field6.RefSparseSharedUnmanaged(i), ref field7.RefSparseSharedUnmanaged(i), ref field8.RefSparseSharedUnmanaged(i), ref field9.RefSparseSharedUnmanaged(i), ref field10.RefSparseSharedUnmanaged(i), ref field11.RefSparseSharedUnmanaged(i), ref field12.RefSparseSharedUnmanaged(i), ref field13.RefSparseSharedUnmanaged(i), ref field14.RefSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefManaged(i), ref field1.RefManaged(i), ref field2.RefManaged(i), ref field3.RefManaged(i), ref field4.RefManaged(i), ref field5.RefManaged(i), ref field6.RefManaged(i), ref field7.RefManaged(i), ref field8.RefManaged(i), ref field9.RefManaged(i), ref field10.RefManaged(i), ref field11.RefManaged(i), ref field12.RefManaged(i), ref field13.RefManaged(i), ref field14.RefManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSharedManaged(i), ref field1.RefSharedManaged(i), ref field2.RefSharedManaged(i), ref field3.RefSharedManaged(i), ref field4.RefSharedManaged(i), ref field5.RefSharedManaged(i), ref field6.RefSharedManaged(i), ref field7.RefSharedManaged(i), ref field8.RefSharedManaged(i), ref field9.RefSharedManaged(i), ref field10.RefSharedManaged(i), ref field11.RefSharedManaged(i), ref field12.RefSharedManaged(i), ref field13.RefSharedManaged(i), ref field14.RefSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSparseManaged(i), ref field1.RefSparseManaged(i), ref field2.RefSparseManaged(i), ref field3.RefSparseManaged(i), ref field4.RefSparseManaged(i), ref field5.RefSparseManaged(i), ref field6.RefSparseManaged(i), ref field7.RefSparseManaged(i), ref field8.RefSparseManaged(i), ref field9.RefSparseManaged(i), ref field10.RefSparseManaged(i), ref field11.RefSparseManaged(i), ref field12.RefSparseManaged(i), ref field13.RefSparseManaged(i), ref field14.RefSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSparseSharedManaged(i), ref field1.RefSparseSharedManaged(i), ref field2.RefSparseSharedManaged(i), ref field3.RefSparseSharedManaged(i), ref field4.RefSparseSharedManaged(i), ref field5.RefSparseSharedManaged(i), ref field6.RefSparseSharedManaged(i), ref field7.RefSparseSharedManaged(i), ref field8.RefSparseSharedManaged(i), ref field9.RefSparseSharedManaged(i), ref field10.RefSparseSharedManaged(i), ref field11.RefSparseSharedManaged(i), ref field12.RefSparseSharedManaged(i), ref field13.RefSparseSharedManaged(i), ref field14.RefSparseSharedManaged(i));
+        }
     }
 
     /// <summary>
@@ -80,15 +316,93 @@ public static void Each<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8); byte* pointer9 = (byte*)it.GetPointer<T9>(9); byte* pointer10 = (byte*)it.GetPointer<T10>(10); byte* pointer11 = (byte*)it.GetPointer<T11>(11); byte* pointer12 = (byte*)it.GetPointer<T12>(12); byte* pointer13 = (byte*)it.GetPointer<T13>(13); byte* pointer14 = (byte*)it.GetPointer<T14>(14);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8); int step9 = it.Step<T9>(9); int step10 = it.Step<T10>(10); int step11 = it.Step<T11>(11); int step12 = it.Step<T12>(12); int step13 = it.Step<T13>(13); int step14 = it.Step<T14>(14);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8); FieldData<T9> field9 = it.GetFieldData<T9>(9); FieldData<T10> field10 = it.GetFieldData<T10>(10); FieldData<T11> field11 = it.GetFieldData<T11>(11); FieldData<T12> field12 = it.GetFieldData<T12>(12); FieldData<T13> field13 = it.GetFieldData<T13>(13); FieldData<T14> field14 = it.GetFieldData<T14>(14);
+        IterationTechnique flags = it.GetIterationTechnique(15);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8], pointer9 = &pointer9[step9], pointer10 = &pointer10[step10], pointer11 = &pointer11[step11], pointer12 = &pointer12[step12], pointer13 = &pointer13[step13], pointer14 = &pointer14[step14])
-            callback(ref Managed.GetTypeRef<T0>(pointer0), ref Managed.GetTypeRef<T1>(pointer1), ref Managed.GetTypeRef<T2>(pointer2), ref Managed.GetTypeRef<T3>(pointer3), ref Managed.GetTypeRef<T4>(pointer4), ref Managed.GetTypeRef<T5>(pointer5), ref Managed.GetTypeRef<T6>(pointer6), ref Managed.GetTypeRef<T7>(pointer7), ref Managed.GetTypeRef<T8>(pointer8), ref Managed.GetTypeRef<T9>(pointer9), ref Managed.GetTypeRef<T10>(pointer10), ref Managed.GetTypeRef<T11>(pointer11), ref Managed.GetTypeRef<T12>(pointer12), ref Managed.GetTypeRef<T13>(pointer13), ref Managed.GetTypeRef<T14>(pointer14));
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>() || RuntimeHelpers.IsReferenceOrContainsReferences<T9>() || RuntimeHelpers.IsReferenceOrContainsReferences<T10>() || RuntimeHelpers.IsReferenceOrContainsReferences<T11>() || RuntimeHelpers.IsReferenceOrContainsReferences<T12>() || RuntimeHelpers.IsReferenceOrContainsReferences<T13>() || RuntimeHelpers.IsReferenceOrContainsReferences<T14>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, ref T14, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefUnmanaged(i), ref field1.RefUnmanaged(i), ref field2.RefUnmanaged(i), ref field3.RefUnmanaged(i), ref field4.RefUnmanaged(i), ref field5.RefUnmanaged(i), ref field6.RefUnmanaged(i), ref field7.RefUnmanaged(i), ref field8.RefUnmanaged(i), ref field9.RefUnmanaged(i), ref field10.RefUnmanaged(i), ref field11.RefUnmanaged(i), ref field12.RefUnmanaged(i), ref field13.RefUnmanaged(i), ref field14.RefUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, ref T14, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSharedUnmanaged(i), ref field1.RefSharedUnmanaged(i), ref field2.RefSharedUnmanaged(i), ref field3.RefSharedUnmanaged(i), ref field4.RefSharedUnmanaged(i), ref field5.RefSharedUnmanaged(i), ref field6.RefSharedUnmanaged(i), ref field7.RefSharedUnmanaged(i), ref field8.RefSharedUnmanaged(i), ref field9.RefSharedUnmanaged(i), ref field10.RefSharedUnmanaged(i), ref field11.RefSharedUnmanaged(i), ref field12.RefSharedUnmanaged(i), ref field13.RefSharedUnmanaged(i), ref field14.RefSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, ref T14, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSparseUnmanaged(i), ref field1.RefSparseUnmanaged(i), ref field2.RefSparseUnmanaged(i), ref field3.RefSparseUnmanaged(i), ref field4.RefSparseUnmanaged(i), ref field5.RefSparseUnmanaged(i), ref field6.RefSparseUnmanaged(i), ref field7.RefSparseUnmanaged(i), ref field8.RefSparseUnmanaged(i), ref field9.RefSparseUnmanaged(i), ref field10.RefSparseUnmanaged(i), ref field11.RefSparseUnmanaged(i), ref field12.RefSparseUnmanaged(i), ref field13.RefSparseUnmanaged(i), ref field14.RefSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, ref T14, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSparseSharedUnmanaged(i), ref field1.RefSparseSharedUnmanaged(i), ref field2.RefSparseSharedUnmanaged(i), ref field3.RefSparseSharedUnmanaged(i), ref field4.RefSparseSharedUnmanaged(i), ref field5.RefSparseSharedUnmanaged(i), ref field6.RefSparseSharedUnmanaged(i), ref field7.RefSparseSharedUnmanaged(i), ref field8.RefSparseSharedUnmanaged(i), ref field9.RefSparseSharedUnmanaged(i), ref field10.RefSparseSharedUnmanaged(i), ref field11.RefSparseSharedUnmanaged(i), ref field12.RefSparseSharedUnmanaged(i), ref field13.RefSparseSharedUnmanaged(i), ref field14.RefSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, ref T14, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefManaged(i), ref field1.RefManaged(i), ref field2.RefManaged(i), ref field3.RefManaged(i), ref field4.RefManaged(i), ref field5.RefManaged(i), ref field6.RefManaged(i), ref field7.RefManaged(i), ref field8.RefManaged(i), ref field9.RefManaged(i), ref field10.RefManaged(i), ref field11.RefManaged(i), ref field12.RefManaged(i), ref field13.RefManaged(i), ref field14.RefManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, ref T14, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSharedManaged(i), ref field1.RefSharedManaged(i), ref field2.RefSharedManaged(i), ref field3.RefSharedManaged(i), ref field4.RefSharedManaged(i), ref field5.RefSharedManaged(i), ref field6.RefSharedManaged(i), ref field7.RefSharedManaged(i), ref field8.RefSharedManaged(i), ref field9.RefSharedManaged(i), ref field10.RefSharedManaged(i), ref field11.RefSharedManaged(i), ref field12.RefSharedManaged(i), ref field13.RefSharedManaged(i), ref field14.RefSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, ref T14, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSparseManaged(i), ref field1.RefSparseManaged(i), ref field2.RefSparseManaged(i), ref field3.RefSparseManaged(i), ref field4.RefSparseManaged(i), ref field5.RefSparseManaged(i), ref field6.RefSparseManaged(i), ref field7.RefSparseManaged(i), ref field8.RefSparseManaged(i), ref field9.RefSparseManaged(i), ref field10.RefSparseManaged(i), ref field11.RefSparseManaged(i), ref field12.RefSparseManaged(i), ref field13.RefSparseManaged(i), ref field14.RefSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, ref T14, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSparseSharedManaged(i), ref field1.RefSparseSharedManaged(i), ref field2.RefSparseSharedManaged(i), ref field3.RefSparseSharedManaged(i), ref field4.RefSparseSharedManaged(i), ref field5.RefSparseSharedManaged(i), ref field6.RefSparseSharedManaged(i), ref field7.RefSparseSharedManaged(i), ref field8.RefSparseSharedManaged(i), ref field9.RefSparseSharedManaged(i), ref field10.RefSparseSharedManaged(i), ref field11.RefSparseSharedManaged(i), ref field12.RefSparseSharedManaged(i), ref field13.RefSparseSharedManaged(i), ref field14.RefSparseSharedManaged(i));
+        }
     }
 
     /// <summary>
@@ -101,15 +415,93 @@ public static void Each<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T
     {
         int count = it.Handle->count; Ecs.Assert(it.Handle->count > 0, "No entities returned, use Iter() or Each() without the entity argument instead.");
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8); byte* pointer9 = (byte*)it.GetPointer<T9>(9); byte* pointer10 = (byte*)it.GetPointer<T10>(10); byte* pointer11 = (byte*)it.GetPointer<T11>(11); byte* pointer12 = (byte*)it.GetPointer<T12>(12); byte* pointer13 = (byte*)it.GetPointer<T13>(13); byte* pointer14 = (byte*)it.GetPointer<T14>(14);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8); int step9 = it.Step<T9>(9); int step10 = it.Step<T10>(10); int step11 = it.Step<T11>(11); int step12 = it.Step<T12>(12); int step13 = it.Step<T13>(13); int step14 = it.Step<T14>(14);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8); FieldData<T9> field9 = it.GetFieldData<T9>(9); FieldData<T10> field10 = it.GetFieldData<T10>(10); FieldData<T11> field11 = it.GetFieldData<T11>(11); FieldData<T12> field12 = it.GetFieldData<T12>(12); FieldData<T13> field13 = it.GetFieldData<T13>(13); FieldData<T14> field14 = it.GetFieldData<T14>(14);
+        IterationTechnique flags = it.GetIterationTechnique(15);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8], pointer9 = &pointer9[step9], pointer10 = &pointer10[step10], pointer11 = &pointer11[step11], pointer12 = &pointer12[step12], pointer13 = &pointer13[step13], pointer14 = &pointer14[step14])
-            callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref Managed.GetTypeRef<T0>(pointer0), ref Managed.GetTypeRef<T1>(pointer1), ref Managed.GetTypeRef<T2>(pointer2), ref Managed.GetTypeRef<T3>(pointer3), ref Managed.GetTypeRef<T4>(pointer4), ref Managed.GetTypeRef<T5>(pointer5), ref Managed.GetTypeRef<T6>(pointer6), ref Managed.GetTypeRef<T7>(pointer7), ref Managed.GetTypeRef<T8>(pointer8), ref Managed.GetTypeRef<T9>(pointer9), ref Managed.GetTypeRef<T10>(pointer10), ref Managed.GetTypeRef<T11>(pointer11), ref Managed.GetTypeRef<T12>(pointer12), ref Managed.GetTypeRef<T13>(pointer13), ref Managed.GetTypeRef<T14>(pointer14));
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>() || RuntimeHelpers.IsReferenceOrContainsReferences<T9>() || RuntimeHelpers.IsReferenceOrContainsReferences<T10>() || RuntimeHelpers.IsReferenceOrContainsReferences<T11>() || RuntimeHelpers.IsReferenceOrContainsReferences<T12>() || RuntimeHelpers.IsReferenceOrContainsReferences<T13>() || RuntimeHelpers.IsReferenceOrContainsReferences<T14>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, ref T14, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefUnmanaged(i), ref field1.RefUnmanaged(i), ref field2.RefUnmanaged(i), ref field3.RefUnmanaged(i), ref field4.RefUnmanaged(i), ref field5.RefUnmanaged(i), ref field6.RefUnmanaged(i), ref field7.RefUnmanaged(i), ref field8.RefUnmanaged(i), ref field9.RefUnmanaged(i), ref field10.RefUnmanaged(i), ref field11.RefUnmanaged(i), ref field12.RefUnmanaged(i), ref field13.RefUnmanaged(i), ref field14.RefUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, ref T14, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSharedUnmanaged(i), ref field1.RefSharedUnmanaged(i), ref field2.RefSharedUnmanaged(i), ref field3.RefSharedUnmanaged(i), ref field4.RefSharedUnmanaged(i), ref field5.RefSharedUnmanaged(i), ref field6.RefSharedUnmanaged(i), ref field7.RefSharedUnmanaged(i), ref field8.RefSharedUnmanaged(i), ref field9.RefSharedUnmanaged(i), ref field10.RefSharedUnmanaged(i), ref field11.RefSharedUnmanaged(i), ref field12.RefSharedUnmanaged(i), ref field13.RefSharedUnmanaged(i), ref field14.RefSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, ref T14, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseUnmanaged(i), ref field1.RefSparseUnmanaged(i), ref field2.RefSparseUnmanaged(i), ref field3.RefSparseUnmanaged(i), ref field4.RefSparseUnmanaged(i), ref field5.RefSparseUnmanaged(i), ref field6.RefSparseUnmanaged(i), ref field7.RefSparseUnmanaged(i), ref field8.RefSparseUnmanaged(i), ref field9.RefSparseUnmanaged(i), ref field10.RefSparseUnmanaged(i), ref field11.RefSparseUnmanaged(i), ref field12.RefSparseUnmanaged(i), ref field13.RefSparseUnmanaged(i), ref field14.RefSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, ref T14, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseSharedUnmanaged(i), ref field1.RefSparseSharedUnmanaged(i), ref field2.RefSparseSharedUnmanaged(i), ref field3.RefSparseSharedUnmanaged(i), ref field4.RefSparseSharedUnmanaged(i), ref field5.RefSparseSharedUnmanaged(i), ref field6.RefSparseSharedUnmanaged(i), ref field7.RefSparseSharedUnmanaged(i), ref field8.RefSparseSharedUnmanaged(i), ref field9.RefSparseSharedUnmanaged(i), ref field10.RefSparseSharedUnmanaged(i), ref field11.RefSparseSharedUnmanaged(i), ref field12.RefSparseSharedUnmanaged(i), ref field13.RefSparseSharedUnmanaged(i), ref field14.RefSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, ref T14, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefManaged(i), ref field1.RefManaged(i), ref field2.RefManaged(i), ref field3.RefManaged(i), ref field4.RefManaged(i), ref field5.RefManaged(i), ref field6.RefManaged(i), ref field7.RefManaged(i), ref field8.RefManaged(i), ref field9.RefManaged(i), ref field10.RefManaged(i), ref field11.RefManaged(i), ref field12.RefManaged(i), ref field13.RefManaged(i), ref field14.RefManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, ref T14, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSharedManaged(i), ref field1.RefSharedManaged(i), ref field2.RefSharedManaged(i), ref field3.RefSharedManaged(i), ref field4.RefSharedManaged(i), ref field5.RefSharedManaged(i), ref field6.RefSharedManaged(i), ref field7.RefSharedManaged(i), ref field8.RefSharedManaged(i), ref field9.RefSharedManaged(i), ref field10.RefSharedManaged(i), ref field11.RefSharedManaged(i), ref field12.RefSharedManaged(i), ref field13.RefSharedManaged(i), ref field14.RefSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, ref T14, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseManaged(i), ref field1.RefSparseManaged(i), ref field2.RefSparseManaged(i), ref field3.RefSparseManaged(i), ref field4.RefSparseManaged(i), ref field5.RefSparseManaged(i), ref field6.RefSparseManaged(i), ref field7.RefSparseManaged(i), ref field8.RefSparseManaged(i), ref field9.RefSparseManaged(i), ref field10.RefSparseManaged(i), ref field11.RefSparseManaged(i), ref field12.RefSparseManaged(i), ref field13.RefSparseManaged(i), ref field14.RefSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, ref T14, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseSharedManaged(i), ref field1.RefSparseSharedManaged(i), ref field2.RefSparseSharedManaged(i), ref field3.RefSparseSharedManaged(i), ref field4.RefSparseSharedManaged(i), ref field5.RefSparseSharedManaged(i), ref field6.RefSparseSharedManaged(i), ref field7.RefSparseSharedManaged(i), ref field8.RefSparseSharedManaged(i), ref field9.RefSparseSharedManaged(i), ref field10.RefSparseSharedManaged(i), ref field11.RefSparseSharedManaged(i), ref field12.RefSparseSharedManaged(i), ref field13.RefSparseSharedManaged(i), ref field14.RefSparseSharedManaged(i));
+        }
     }
 
     /// <summary>
@@ -122,15 +514,93 @@ public static void Each<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8); byte* pointer9 = (byte*)it.GetPointer<T9>(9); byte* pointer10 = (byte*)it.GetPointer<T10>(10); byte* pointer11 = (byte*)it.GetPointer<T11>(11); byte* pointer12 = (byte*)it.GetPointer<T12>(12); byte* pointer13 = (byte*)it.GetPointer<T13>(13); byte* pointer14 = (byte*)it.GetPointer<T14>(14);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8); int step9 = it.Step<T9>(9); int step10 = it.Step<T10>(10); int step11 = it.Step<T11>(11); int step12 = it.Step<T12>(12); int step13 = it.Step<T13>(13); int step14 = it.Step<T14>(14);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8); FieldData<T9> field9 = it.GetFieldData<T9>(9); FieldData<T10> field10 = it.GetFieldData<T10>(10); FieldData<T11> field11 = it.GetFieldData<T11>(11); FieldData<T12> field12 = it.GetFieldData<T12>(12); FieldData<T13> field13 = it.GetFieldData<T13>(13); FieldData<T14> field14 = it.GetFieldData<T14>(14);
+        IterationTechnique flags = it.GetIterationTechnique(15);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8], pointer9 = &pointer9[step9], pointer10 = &pointer10[step10], pointer11 = &pointer11[step11], pointer12 = &pointer12[step12], pointer13 = &pointer13[step13], pointer14 = &pointer14[step14])
-            callback(it, i, ref Managed.GetTypeRef<T0>(pointer0), ref Managed.GetTypeRef<T1>(pointer1), ref Managed.GetTypeRef<T2>(pointer2), ref Managed.GetTypeRef<T3>(pointer3), ref Managed.GetTypeRef<T4>(pointer4), ref Managed.GetTypeRef<T5>(pointer5), ref Managed.GetTypeRef<T6>(pointer6), ref Managed.GetTypeRef<T7>(pointer7), ref Managed.GetTypeRef<T8>(pointer8), ref Managed.GetTypeRef<T9>(pointer9), ref Managed.GetTypeRef<T10>(pointer10), ref Managed.GetTypeRef<T11>(pointer11), ref Managed.GetTypeRef<T12>(pointer12), ref Managed.GetTypeRef<T13>(pointer13), ref Managed.GetTypeRef<T14>(pointer14));
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>() || RuntimeHelpers.IsReferenceOrContainsReferences<T9>() || RuntimeHelpers.IsReferenceOrContainsReferences<T10>() || RuntimeHelpers.IsReferenceOrContainsReferences<T11>() || RuntimeHelpers.IsReferenceOrContainsReferences<T12>() || RuntimeHelpers.IsReferenceOrContainsReferences<T13>() || RuntimeHelpers.IsReferenceOrContainsReferences<T14>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, ref T14, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefUnmanaged(i), ref field1.RefUnmanaged(i), ref field2.RefUnmanaged(i), ref field3.RefUnmanaged(i), ref field4.RefUnmanaged(i), ref field5.RefUnmanaged(i), ref field6.RefUnmanaged(i), ref field7.RefUnmanaged(i), ref field8.RefUnmanaged(i), ref field9.RefUnmanaged(i), ref field10.RefUnmanaged(i), ref field11.RefUnmanaged(i), ref field12.RefUnmanaged(i), ref field13.RefUnmanaged(i), ref field14.RefUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, ref T14, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSharedUnmanaged(i), ref field1.RefSharedUnmanaged(i), ref field2.RefSharedUnmanaged(i), ref field3.RefSharedUnmanaged(i), ref field4.RefSharedUnmanaged(i), ref field5.RefSharedUnmanaged(i), ref field6.RefSharedUnmanaged(i), ref field7.RefSharedUnmanaged(i), ref field8.RefSharedUnmanaged(i), ref field9.RefSharedUnmanaged(i), ref field10.RefSharedUnmanaged(i), ref field11.RefSharedUnmanaged(i), ref field12.RefSharedUnmanaged(i), ref field13.RefSharedUnmanaged(i), ref field14.RefSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, ref T14, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSparseUnmanaged(i), ref field1.RefSparseUnmanaged(i), ref field2.RefSparseUnmanaged(i), ref field3.RefSparseUnmanaged(i), ref field4.RefSparseUnmanaged(i), ref field5.RefSparseUnmanaged(i), ref field6.RefSparseUnmanaged(i), ref field7.RefSparseUnmanaged(i), ref field8.RefSparseUnmanaged(i), ref field9.RefSparseUnmanaged(i), ref field10.RefSparseUnmanaged(i), ref field11.RefSparseUnmanaged(i), ref field12.RefSparseUnmanaged(i), ref field13.RefSparseUnmanaged(i), ref field14.RefSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, ref T14, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSparseSharedUnmanaged(i), ref field1.RefSparseSharedUnmanaged(i), ref field2.RefSparseSharedUnmanaged(i), ref field3.RefSparseSharedUnmanaged(i), ref field4.RefSparseSharedUnmanaged(i), ref field5.RefSparseSharedUnmanaged(i), ref field6.RefSparseSharedUnmanaged(i), ref field7.RefSparseSharedUnmanaged(i), ref field8.RefSparseSharedUnmanaged(i), ref field9.RefSparseSharedUnmanaged(i), ref field10.RefSparseSharedUnmanaged(i), ref field11.RefSparseSharedUnmanaged(i), ref field12.RefSparseSharedUnmanaged(i), ref field13.RefSparseSharedUnmanaged(i), ref field14.RefSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, ref T14, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefManaged(i), ref field1.RefManaged(i), ref field2.RefManaged(i), ref field3.RefManaged(i), ref field4.RefManaged(i), ref field5.RefManaged(i), ref field6.RefManaged(i), ref field7.RefManaged(i), ref field8.RefManaged(i), ref field9.RefManaged(i), ref field10.RefManaged(i), ref field11.RefManaged(i), ref field12.RefManaged(i), ref field13.RefManaged(i), ref field14.RefManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, ref T14, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSharedManaged(i), ref field1.RefSharedManaged(i), ref field2.RefSharedManaged(i), ref field3.RefSharedManaged(i), ref field4.RefSharedManaged(i), ref field5.RefSharedManaged(i), ref field6.RefSharedManaged(i), ref field7.RefSharedManaged(i), ref field8.RefSharedManaged(i), ref field9.RefSharedManaged(i), ref field10.RefSharedManaged(i), ref field11.RefSharedManaged(i), ref field12.RefSharedManaged(i), ref field13.RefSharedManaged(i), ref field14.RefSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, ref T14, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSparseManaged(i), ref field1.RefSparseManaged(i), ref field2.RefSparseManaged(i), ref field3.RefSparseManaged(i), ref field4.RefSparseManaged(i), ref field5.RefSparseManaged(i), ref field6.RefSparseManaged(i), ref field7.RefSparseManaged(i), ref field8.RefSparseManaged(i), ref field9.RefSparseManaged(i), ref field10.RefSparseManaged(i), ref field11.RefSparseManaged(i), ref field12.RefSparseManaged(i), ref field13.RefSparseManaged(i), ref field14.RefSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, ref T14, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSparseSharedManaged(i), ref field1.RefSparseSharedManaged(i), ref field2.RefSparseSharedManaged(i), ref field3.RefSparseSharedManaged(i), ref field4.RefSparseSharedManaged(i), ref field5.RefSparseSharedManaged(i), ref field6.RefSparseSharedManaged(i), ref field7.RefSparseSharedManaged(i), ref field8.RefSparseSharedManaged(i), ref field9.RefSparseSharedManaged(i), ref field10.RefSparseSharedManaged(i), ref field11.RefSparseSharedManaged(i), ref field12.RefSparseSharedManaged(i), ref field13.RefSparseSharedManaged(i), ref field14.RefSparseSharedManaged(i));
+        }
     }
 
     /// <summary>
@@ -143,15 +613,93 @@ public static void Each<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8); byte* pointer9 = (byte*)it.GetPointer<T9>(9); byte* pointer10 = (byte*)it.GetPointer<T10>(10); byte* pointer11 = (byte*)it.GetPointer<T11>(11); byte* pointer12 = (byte*)it.GetPointer<T12>(12); byte* pointer13 = (byte*)it.GetPointer<T13>(13); byte* pointer14 = (byte*)it.GetPointer<T14>(14);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8); int step9 = it.Step<T9>(9); int step10 = it.Step<T10>(10); int step11 = it.Step<T11>(11); int step12 = it.Step<T12>(12); int step13 = it.Step<T13>(13); int step14 = it.Step<T14>(14);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8); FieldData<T9> field9 = it.GetFieldData<T9>(9); FieldData<T10> field10 = it.GetFieldData<T10>(10); FieldData<T11> field11 = it.GetFieldData<T11>(11); FieldData<T12> field12 = it.GetFieldData<T12>(12); FieldData<T13> field13 = it.GetFieldData<T13>(13); FieldData<T14> field14 = it.GetFieldData<T14>(14);
+        IterationTechnique flags = it.GetIterationTechnique(15);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8], pointer9 = &pointer9[step9], pointer10 = &pointer10[step10], pointer11 = &pointer11[step11], pointer12 = &pointer12[step12], pointer13 = &pointer13[step13], pointer14 = &pointer14[step14])
-            callback((T0*)pointer0, (T1*)pointer1, (T2*)pointer2, (T3*)pointer3, (T4*)pointer4, (T5*)pointer5, (T6*)pointer6, (T7*)pointer7, (T8*)pointer8, (T9*)pointer9, (T10*)pointer10, (T11*)pointer11, (T12*)pointer12, (T13*)pointer13, (T14*)pointer14);
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>() || RuntimeHelpers.IsReferenceOrContainsReferences<T9>() || RuntimeHelpers.IsReferenceOrContainsReferences<T10>() || RuntimeHelpers.IsReferenceOrContainsReferences<T11>() || RuntimeHelpers.IsReferenceOrContainsReferences<T12>() || RuntimeHelpers.IsReferenceOrContainsReferences<T13>() || RuntimeHelpers.IsReferenceOrContainsReferences<T14>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerUnmanaged(i), field1.PointerUnmanaged(i), field2.PointerUnmanaged(i), field3.PointerUnmanaged(i), field4.PointerUnmanaged(i), field5.PointerUnmanaged(i), field6.PointerUnmanaged(i), field7.PointerUnmanaged(i), field8.PointerUnmanaged(i), field9.PointerUnmanaged(i), field10.PointerUnmanaged(i), field11.PointerUnmanaged(i), field12.PointerUnmanaged(i), field13.PointerUnmanaged(i), field14.PointerUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSharedUnmanaged(i), field1.PointerSharedUnmanaged(i), field2.PointerSharedUnmanaged(i), field3.PointerSharedUnmanaged(i), field4.PointerSharedUnmanaged(i), field5.PointerSharedUnmanaged(i), field6.PointerSharedUnmanaged(i), field7.PointerSharedUnmanaged(i), field8.PointerSharedUnmanaged(i), field9.PointerSharedUnmanaged(i), field10.PointerSharedUnmanaged(i), field11.PointerSharedUnmanaged(i), field12.PointerSharedUnmanaged(i), field13.PointerSharedUnmanaged(i), field14.PointerSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSparseUnmanaged(i), field1.PointerSparseUnmanaged(i), field2.PointerSparseUnmanaged(i), field3.PointerSparseUnmanaged(i), field4.PointerSparseUnmanaged(i), field5.PointerSparseUnmanaged(i), field6.PointerSparseUnmanaged(i), field7.PointerSparseUnmanaged(i), field8.PointerSparseUnmanaged(i), field9.PointerSparseUnmanaged(i), field10.PointerSparseUnmanaged(i), field11.PointerSparseUnmanaged(i), field12.PointerSparseUnmanaged(i), field13.PointerSparseUnmanaged(i), field14.PointerSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSparseSharedUnmanaged(i), field1.PointerSparseSharedUnmanaged(i), field2.PointerSparseSharedUnmanaged(i), field3.PointerSparseSharedUnmanaged(i), field4.PointerSparseSharedUnmanaged(i), field5.PointerSparseSharedUnmanaged(i), field6.PointerSparseSharedUnmanaged(i), field7.PointerSparseSharedUnmanaged(i), field8.PointerSparseSharedUnmanaged(i), field9.PointerSparseSharedUnmanaged(i), field10.PointerSparseSharedUnmanaged(i), field11.PointerSparseSharedUnmanaged(i), field12.PointerSparseSharedUnmanaged(i), field13.PointerSparseSharedUnmanaged(i), field14.PointerSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerManaged(i), field1.PointerManaged(i), field2.PointerManaged(i), field3.PointerManaged(i), field4.PointerManaged(i), field5.PointerManaged(i), field6.PointerManaged(i), field7.PointerManaged(i), field8.PointerManaged(i), field9.PointerManaged(i), field10.PointerManaged(i), field11.PointerManaged(i), field12.PointerManaged(i), field13.PointerManaged(i), field14.PointerManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSharedManaged(i), field1.PointerSharedManaged(i), field2.PointerSharedManaged(i), field3.PointerSharedManaged(i), field4.PointerSharedManaged(i), field5.PointerSharedManaged(i), field6.PointerSharedManaged(i), field7.PointerSharedManaged(i), field8.PointerSharedManaged(i), field9.PointerSharedManaged(i), field10.PointerSharedManaged(i), field11.PointerSharedManaged(i), field12.PointerSharedManaged(i), field13.PointerSharedManaged(i), field14.PointerSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSparseManaged(i), field1.PointerSparseManaged(i), field2.PointerSparseManaged(i), field3.PointerSparseManaged(i), field4.PointerSparseManaged(i), field5.PointerSparseManaged(i), field6.PointerSparseManaged(i), field7.PointerSparseManaged(i), field8.PointerSparseManaged(i), field9.PointerSparseManaged(i), field10.PointerSparseManaged(i), field11.PointerSparseManaged(i), field12.PointerSparseManaged(i), field13.PointerSparseManaged(i), field14.PointerSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSparseSharedManaged(i), field1.PointerSparseSharedManaged(i), field2.PointerSparseSharedManaged(i), field3.PointerSparseSharedManaged(i), field4.PointerSparseSharedManaged(i), field5.PointerSparseSharedManaged(i), field6.PointerSparseSharedManaged(i), field7.PointerSparseSharedManaged(i), field8.PointerSparseSharedManaged(i), field9.PointerSparseSharedManaged(i), field10.PointerSparseSharedManaged(i), field11.PointerSparseSharedManaged(i), field12.PointerSparseSharedManaged(i), field13.PointerSparseSharedManaged(i), field14.PointerSparseSharedManaged(i));
+        }
     }
 
     /// <summary>
@@ -164,15 +712,93 @@ public static void Each<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T
     {
         int count = it.Handle->count; Ecs.Assert(it.Handle->count > 0, "No entities returned, use Iter() or Each() without the entity argument instead.");
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8); byte* pointer9 = (byte*)it.GetPointer<T9>(9); byte* pointer10 = (byte*)it.GetPointer<T10>(10); byte* pointer11 = (byte*)it.GetPointer<T11>(11); byte* pointer12 = (byte*)it.GetPointer<T12>(12); byte* pointer13 = (byte*)it.GetPointer<T13>(13); byte* pointer14 = (byte*)it.GetPointer<T14>(14);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8); int step9 = it.Step<T9>(9); int step10 = it.Step<T10>(10); int step11 = it.Step<T11>(11); int step12 = it.Step<T12>(12); int step13 = it.Step<T13>(13); int step14 = it.Step<T14>(14);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8); FieldData<T9> field9 = it.GetFieldData<T9>(9); FieldData<T10> field10 = it.GetFieldData<T10>(10); FieldData<T11> field11 = it.GetFieldData<T11>(11); FieldData<T12> field12 = it.GetFieldData<T12>(12); FieldData<T13> field13 = it.GetFieldData<T13>(13); FieldData<T14> field14 = it.GetFieldData<T14>(14);
+        IterationTechnique flags = it.GetIterationTechnique(15);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8], pointer9 = &pointer9[step9], pointer10 = &pointer10[step10], pointer11 = &pointer11[step11], pointer12 = &pointer12[step12], pointer13 = &pointer13[step13], pointer14 = &pointer14[step14])
-            callback(new Entity(it.Handle->world, it.Handle->entities[i]), (T0*)pointer0, (T1*)pointer1, (T2*)pointer2, (T3*)pointer3, (T4*)pointer4, (T5*)pointer5, (T6*)pointer6, (T7*)pointer7, (T8*)pointer8, (T9*)pointer9, (T10*)pointer10, (T11*)pointer11, (T12*)pointer12, (T13*)pointer13, (T14*)pointer14);
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>() || RuntimeHelpers.IsReferenceOrContainsReferences<T9>() || RuntimeHelpers.IsReferenceOrContainsReferences<T10>() || RuntimeHelpers.IsReferenceOrContainsReferences<T11>() || RuntimeHelpers.IsReferenceOrContainsReferences<T12>() || RuntimeHelpers.IsReferenceOrContainsReferences<T13>() || RuntimeHelpers.IsReferenceOrContainsReferences<T14>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerUnmanaged(i), field1.PointerUnmanaged(i), field2.PointerUnmanaged(i), field3.PointerUnmanaged(i), field4.PointerUnmanaged(i), field5.PointerUnmanaged(i), field6.PointerUnmanaged(i), field7.PointerUnmanaged(i), field8.PointerUnmanaged(i), field9.PointerUnmanaged(i), field10.PointerUnmanaged(i), field11.PointerUnmanaged(i), field12.PointerUnmanaged(i), field13.PointerUnmanaged(i), field14.PointerUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSharedUnmanaged(i), field1.PointerSharedUnmanaged(i), field2.PointerSharedUnmanaged(i), field3.PointerSharedUnmanaged(i), field4.PointerSharedUnmanaged(i), field5.PointerSharedUnmanaged(i), field6.PointerSharedUnmanaged(i), field7.PointerSharedUnmanaged(i), field8.PointerSharedUnmanaged(i), field9.PointerSharedUnmanaged(i), field10.PointerSharedUnmanaged(i), field11.PointerSharedUnmanaged(i), field12.PointerSharedUnmanaged(i), field13.PointerSharedUnmanaged(i), field14.PointerSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseUnmanaged(i), field1.PointerSparseUnmanaged(i), field2.PointerSparseUnmanaged(i), field3.PointerSparseUnmanaged(i), field4.PointerSparseUnmanaged(i), field5.PointerSparseUnmanaged(i), field6.PointerSparseUnmanaged(i), field7.PointerSparseUnmanaged(i), field8.PointerSparseUnmanaged(i), field9.PointerSparseUnmanaged(i), field10.PointerSparseUnmanaged(i), field11.PointerSparseUnmanaged(i), field12.PointerSparseUnmanaged(i), field13.PointerSparseUnmanaged(i), field14.PointerSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseSharedUnmanaged(i), field1.PointerSparseSharedUnmanaged(i), field2.PointerSparseSharedUnmanaged(i), field3.PointerSparseSharedUnmanaged(i), field4.PointerSparseSharedUnmanaged(i), field5.PointerSparseSharedUnmanaged(i), field6.PointerSparseSharedUnmanaged(i), field7.PointerSparseSharedUnmanaged(i), field8.PointerSparseSharedUnmanaged(i), field9.PointerSparseSharedUnmanaged(i), field10.PointerSparseSharedUnmanaged(i), field11.PointerSparseSharedUnmanaged(i), field12.PointerSparseSharedUnmanaged(i), field13.PointerSparseSharedUnmanaged(i), field14.PointerSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerManaged(i), field1.PointerManaged(i), field2.PointerManaged(i), field3.PointerManaged(i), field4.PointerManaged(i), field5.PointerManaged(i), field6.PointerManaged(i), field7.PointerManaged(i), field8.PointerManaged(i), field9.PointerManaged(i), field10.PointerManaged(i), field11.PointerManaged(i), field12.PointerManaged(i), field13.PointerManaged(i), field14.PointerManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSharedManaged(i), field1.PointerSharedManaged(i), field2.PointerSharedManaged(i), field3.PointerSharedManaged(i), field4.PointerSharedManaged(i), field5.PointerSharedManaged(i), field6.PointerSharedManaged(i), field7.PointerSharedManaged(i), field8.PointerSharedManaged(i), field9.PointerSharedManaged(i), field10.PointerSharedManaged(i), field11.PointerSharedManaged(i), field12.PointerSharedManaged(i), field13.PointerSharedManaged(i), field14.PointerSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseManaged(i), field1.PointerSparseManaged(i), field2.PointerSparseManaged(i), field3.PointerSparseManaged(i), field4.PointerSparseManaged(i), field5.PointerSparseManaged(i), field6.PointerSparseManaged(i), field7.PointerSparseManaged(i), field8.PointerSparseManaged(i), field9.PointerSparseManaged(i), field10.PointerSparseManaged(i), field11.PointerSparseManaged(i), field12.PointerSparseManaged(i), field13.PointerSparseManaged(i), field14.PointerSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseSharedManaged(i), field1.PointerSparseSharedManaged(i), field2.PointerSparseSharedManaged(i), field3.PointerSparseSharedManaged(i), field4.PointerSparseSharedManaged(i), field5.PointerSparseSharedManaged(i), field6.PointerSparseSharedManaged(i), field7.PointerSparseSharedManaged(i), field8.PointerSparseSharedManaged(i), field9.PointerSparseSharedManaged(i), field10.PointerSparseSharedManaged(i), field11.PointerSparseSharedManaged(i), field12.PointerSparseSharedManaged(i), field13.PointerSparseSharedManaged(i), field14.PointerSparseSharedManaged(i));
+        }
     }
 
     /// <summary>
@@ -185,15 +811,93 @@ public static void Each<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8); byte* pointer9 = (byte*)it.GetPointer<T9>(9); byte* pointer10 = (byte*)it.GetPointer<T10>(10); byte* pointer11 = (byte*)it.GetPointer<T11>(11); byte* pointer12 = (byte*)it.GetPointer<T12>(12); byte* pointer13 = (byte*)it.GetPointer<T13>(13); byte* pointer14 = (byte*)it.GetPointer<T14>(14);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8); int step9 = it.Step<T9>(9); int step10 = it.Step<T10>(10); int step11 = it.Step<T11>(11); int step12 = it.Step<T12>(12); int step13 = it.Step<T13>(13); int step14 = it.Step<T14>(14);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8); FieldData<T9> field9 = it.GetFieldData<T9>(9); FieldData<T10> field10 = it.GetFieldData<T10>(10); FieldData<T11> field11 = it.GetFieldData<T11>(11); FieldData<T12> field12 = it.GetFieldData<T12>(12); FieldData<T13> field13 = it.GetFieldData<T13>(13); FieldData<T14> field14 = it.GetFieldData<T14>(14);
+        IterationTechnique flags = it.GetIterationTechnique(15);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8], pointer9 = &pointer9[step9], pointer10 = &pointer10[step10], pointer11 = &pointer11[step11], pointer12 = &pointer12[step12], pointer13 = &pointer13[step13], pointer14 = &pointer14[step14])
-            callback(it, i, (T0*)pointer0, (T1*)pointer1, (T2*)pointer2, (T3*)pointer3, (T4*)pointer4, (T5*)pointer5, (T6*)pointer6, (T7*)pointer7, (T8*)pointer8, (T9*)pointer9, (T10*)pointer10, (T11*)pointer11, (T12*)pointer12, (T13*)pointer13, (T14*)pointer14);
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>() || RuntimeHelpers.IsReferenceOrContainsReferences<T9>() || RuntimeHelpers.IsReferenceOrContainsReferences<T10>() || RuntimeHelpers.IsReferenceOrContainsReferences<T11>() || RuntimeHelpers.IsReferenceOrContainsReferences<T12>() || RuntimeHelpers.IsReferenceOrContainsReferences<T13>() || RuntimeHelpers.IsReferenceOrContainsReferences<T14>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerUnmanaged(i), field1.PointerUnmanaged(i), field2.PointerUnmanaged(i), field3.PointerUnmanaged(i), field4.PointerUnmanaged(i), field5.PointerUnmanaged(i), field6.PointerUnmanaged(i), field7.PointerUnmanaged(i), field8.PointerUnmanaged(i), field9.PointerUnmanaged(i), field10.PointerUnmanaged(i), field11.PointerUnmanaged(i), field12.PointerUnmanaged(i), field13.PointerUnmanaged(i), field14.PointerUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSharedUnmanaged(i), field1.PointerSharedUnmanaged(i), field2.PointerSharedUnmanaged(i), field3.PointerSharedUnmanaged(i), field4.PointerSharedUnmanaged(i), field5.PointerSharedUnmanaged(i), field6.PointerSharedUnmanaged(i), field7.PointerSharedUnmanaged(i), field8.PointerSharedUnmanaged(i), field9.PointerSharedUnmanaged(i), field10.PointerSharedUnmanaged(i), field11.PointerSharedUnmanaged(i), field12.PointerSharedUnmanaged(i), field13.PointerSharedUnmanaged(i), field14.PointerSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSparseUnmanaged(i), field1.PointerSparseUnmanaged(i), field2.PointerSparseUnmanaged(i), field3.PointerSparseUnmanaged(i), field4.PointerSparseUnmanaged(i), field5.PointerSparseUnmanaged(i), field6.PointerSparseUnmanaged(i), field7.PointerSparseUnmanaged(i), field8.PointerSparseUnmanaged(i), field9.PointerSparseUnmanaged(i), field10.PointerSparseUnmanaged(i), field11.PointerSparseUnmanaged(i), field12.PointerSparseUnmanaged(i), field13.PointerSparseUnmanaged(i), field14.PointerSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSparseSharedUnmanaged(i), field1.PointerSparseSharedUnmanaged(i), field2.PointerSparseSharedUnmanaged(i), field3.PointerSparseSharedUnmanaged(i), field4.PointerSparseSharedUnmanaged(i), field5.PointerSparseSharedUnmanaged(i), field6.PointerSparseSharedUnmanaged(i), field7.PointerSparseSharedUnmanaged(i), field8.PointerSparseSharedUnmanaged(i), field9.PointerSparseSharedUnmanaged(i), field10.PointerSparseSharedUnmanaged(i), field11.PointerSparseSharedUnmanaged(i), field12.PointerSparseSharedUnmanaged(i), field13.PointerSparseSharedUnmanaged(i), field14.PointerSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerManaged(i), field1.PointerManaged(i), field2.PointerManaged(i), field3.PointerManaged(i), field4.PointerManaged(i), field5.PointerManaged(i), field6.PointerManaged(i), field7.PointerManaged(i), field8.PointerManaged(i), field9.PointerManaged(i), field10.PointerManaged(i), field11.PointerManaged(i), field12.PointerManaged(i), field13.PointerManaged(i), field14.PointerManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSharedManaged(i), field1.PointerSharedManaged(i), field2.PointerSharedManaged(i), field3.PointerSharedManaged(i), field4.PointerSharedManaged(i), field5.PointerSharedManaged(i), field6.PointerSharedManaged(i), field7.PointerSharedManaged(i), field8.PointerSharedManaged(i), field9.PointerSharedManaged(i), field10.PointerSharedManaged(i), field11.PointerSharedManaged(i), field12.PointerSharedManaged(i), field13.PointerSharedManaged(i), field14.PointerSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSparseManaged(i), field1.PointerSparseManaged(i), field2.PointerSparseManaged(i), field3.PointerSparseManaged(i), field4.PointerSparseManaged(i), field5.PointerSparseManaged(i), field6.PointerSparseManaged(i), field7.PointerSparseManaged(i), field8.PointerSparseManaged(i), field9.PointerSparseManaged(i), field10.PointerSparseManaged(i), field11.PointerSparseManaged(i), field12.PointerSparseManaged(i), field13.PointerSparseManaged(i), field14.PointerSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSparseSharedManaged(i), field1.PointerSparseSharedManaged(i), field2.PointerSparseSharedManaged(i), field3.PointerSparseSharedManaged(i), field4.PointerSparseSharedManaged(i), field5.PointerSparseSharedManaged(i), field6.PointerSparseSharedManaged(i), field7.PointerSparseSharedManaged(i), field8.PointerSparseSharedManaged(i), field9.PointerSparseSharedManaged(i), field10.PointerSparseSharedManaged(i), field11.PointerSparseSharedManaged(i), field12.PointerSparseSharedManaged(i), field13.PointerSparseSharedManaged(i), field14.PointerSparseSharedManaged(i));
+        }
     }
 
     /// <summary>
@@ -206,15 +910,93 @@ public static void Each<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8); byte* pointer9 = (byte*)it.GetPointer<T9>(9); byte* pointer10 = (byte*)it.GetPointer<T10>(10); byte* pointer11 = (byte*)it.GetPointer<T11>(11); byte* pointer12 = (byte*)it.GetPointer<T12>(12); byte* pointer13 = (byte*)it.GetPointer<T13>(13); byte* pointer14 = (byte*)it.GetPointer<T14>(14);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8); int step9 = it.Step<T9>(9); int step10 = it.Step<T10>(10); int step11 = it.Step<T11>(11); int step12 = it.Step<T12>(12); int step13 = it.Step<T13>(13); int step14 = it.Step<T14>(14);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8); FieldData<T9> field9 = it.GetFieldData<T9>(9); FieldData<T10> field10 = it.GetFieldData<T10>(10); FieldData<T11> field11 = it.GetFieldData<T11>(11); FieldData<T12> field12 = it.GetFieldData<T12>(12); FieldData<T13> field13 = it.GetFieldData<T13>(13); FieldData<T14> field14 = it.GetFieldData<T14>(14);
+        IterationTechnique flags = it.GetIterationTechnique(15);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8], pointer9 = &pointer9[step9], pointer10 = &pointer10[step10], pointer11 = &pointer11[step11], pointer12 = &pointer12[step12], pointer13 = &pointer13[step13], pointer14 = &pointer14[step14])
-            callback((T0*)pointer0, (T1*)pointer1, (T2*)pointer2, (T3*)pointer3, (T4*)pointer4, (T5*)pointer5, (T6*)pointer6, (T7*)pointer7, (T8*)pointer8, (T9*)pointer9, (T10*)pointer10, (T11*)pointer11, (T12*)pointer12, (T13*)pointer13, (T14*)pointer14);
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>() || RuntimeHelpers.IsReferenceOrContainsReferences<T9>() || RuntimeHelpers.IsReferenceOrContainsReferences<T10>() || RuntimeHelpers.IsReferenceOrContainsReferences<T11>() || RuntimeHelpers.IsReferenceOrContainsReferences<T12>() || RuntimeHelpers.IsReferenceOrContainsReferences<T13>() || RuntimeHelpers.IsReferenceOrContainsReferences<T14>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, T14*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerUnmanaged(i), field1.PointerUnmanaged(i), field2.PointerUnmanaged(i), field3.PointerUnmanaged(i), field4.PointerUnmanaged(i), field5.PointerUnmanaged(i), field6.PointerUnmanaged(i), field7.PointerUnmanaged(i), field8.PointerUnmanaged(i), field9.PointerUnmanaged(i), field10.PointerUnmanaged(i), field11.PointerUnmanaged(i), field12.PointerUnmanaged(i), field13.PointerUnmanaged(i), field14.PointerUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, T14*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSharedUnmanaged(i), field1.PointerSharedUnmanaged(i), field2.PointerSharedUnmanaged(i), field3.PointerSharedUnmanaged(i), field4.PointerSharedUnmanaged(i), field5.PointerSharedUnmanaged(i), field6.PointerSharedUnmanaged(i), field7.PointerSharedUnmanaged(i), field8.PointerSharedUnmanaged(i), field9.PointerSharedUnmanaged(i), field10.PointerSharedUnmanaged(i), field11.PointerSharedUnmanaged(i), field12.PointerSharedUnmanaged(i), field13.PointerSharedUnmanaged(i), field14.PointerSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, T14*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSparseUnmanaged(i), field1.PointerSparseUnmanaged(i), field2.PointerSparseUnmanaged(i), field3.PointerSparseUnmanaged(i), field4.PointerSparseUnmanaged(i), field5.PointerSparseUnmanaged(i), field6.PointerSparseUnmanaged(i), field7.PointerSparseUnmanaged(i), field8.PointerSparseUnmanaged(i), field9.PointerSparseUnmanaged(i), field10.PointerSparseUnmanaged(i), field11.PointerSparseUnmanaged(i), field12.PointerSparseUnmanaged(i), field13.PointerSparseUnmanaged(i), field14.PointerSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, T14*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSparseSharedUnmanaged(i), field1.PointerSparseSharedUnmanaged(i), field2.PointerSparseSharedUnmanaged(i), field3.PointerSparseSharedUnmanaged(i), field4.PointerSparseSharedUnmanaged(i), field5.PointerSparseSharedUnmanaged(i), field6.PointerSparseSharedUnmanaged(i), field7.PointerSparseSharedUnmanaged(i), field8.PointerSparseSharedUnmanaged(i), field9.PointerSparseSharedUnmanaged(i), field10.PointerSparseSharedUnmanaged(i), field11.PointerSparseSharedUnmanaged(i), field12.PointerSparseSharedUnmanaged(i), field13.PointerSparseSharedUnmanaged(i), field14.PointerSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, T14*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerManaged(i), field1.PointerManaged(i), field2.PointerManaged(i), field3.PointerManaged(i), field4.PointerManaged(i), field5.PointerManaged(i), field6.PointerManaged(i), field7.PointerManaged(i), field8.PointerManaged(i), field9.PointerManaged(i), field10.PointerManaged(i), field11.PointerManaged(i), field12.PointerManaged(i), field13.PointerManaged(i), field14.PointerManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, T14*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSharedManaged(i), field1.PointerSharedManaged(i), field2.PointerSharedManaged(i), field3.PointerSharedManaged(i), field4.PointerSharedManaged(i), field5.PointerSharedManaged(i), field6.PointerSharedManaged(i), field7.PointerSharedManaged(i), field8.PointerSharedManaged(i), field9.PointerSharedManaged(i), field10.PointerSharedManaged(i), field11.PointerSharedManaged(i), field12.PointerSharedManaged(i), field13.PointerSharedManaged(i), field14.PointerSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, T14*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSparseManaged(i), field1.PointerSparseManaged(i), field2.PointerSparseManaged(i), field3.PointerSparseManaged(i), field4.PointerSparseManaged(i), field5.PointerSparseManaged(i), field6.PointerSparseManaged(i), field7.PointerSparseManaged(i), field8.PointerSparseManaged(i), field9.PointerSparseManaged(i), field10.PointerSparseManaged(i), field11.PointerSparseManaged(i), field12.PointerSparseManaged(i), field13.PointerSparseManaged(i), field14.PointerSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, T14*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSparseSharedManaged(i), field1.PointerSparseSharedManaged(i), field2.PointerSparseSharedManaged(i), field3.PointerSparseSharedManaged(i), field4.PointerSparseSharedManaged(i), field5.PointerSparseSharedManaged(i), field6.PointerSparseSharedManaged(i), field7.PointerSparseSharedManaged(i), field8.PointerSparseSharedManaged(i), field9.PointerSparseSharedManaged(i), field10.PointerSparseSharedManaged(i), field11.PointerSparseSharedManaged(i), field12.PointerSparseSharedManaged(i), field13.PointerSparseSharedManaged(i), field14.PointerSparseSharedManaged(i));
+        }
     }
 
     /// <summary>
@@ -227,15 +1009,93 @@ public static void Each<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T
     {
         int count = it.Handle->count; Ecs.Assert(it.Handle->count > 0, "No entities returned, use Iter() or Each() without the entity argument instead.");
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8); byte* pointer9 = (byte*)it.GetPointer<T9>(9); byte* pointer10 = (byte*)it.GetPointer<T10>(10); byte* pointer11 = (byte*)it.GetPointer<T11>(11); byte* pointer12 = (byte*)it.GetPointer<T12>(12); byte* pointer13 = (byte*)it.GetPointer<T13>(13); byte* pointer14 = (byte*)it.GetPointer<T14>(14);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8); int step9 = it.Step<T9>(9); int step10 = it.Step<T10>(10); int step11 = it.Step<T11>(11); int step12 = it.Step<T12>(12); int step13 = it.Step<T13>(13); int step14 = it.Step<T14>(14);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8); FieldData<T9> field9 = it.GetFieldData<T9>(9); FieldData<T10> field10 = it.GetFieldData<T10>(10); FieldData<T11> field11 = it.GetFieldData<T11>(11); FieldData<T12> field12 = it.GetFieldData<T12>(12); FieldData<T13> field13 = it.GetFieldData<T13>(13); FieldData<T14> field14 = it.GetFieldData<T14>(14);
+        IterationTechnique flags = it.GetIterationTechnique(15);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8], pointer9 = &pointer9[step9], pointer10 = &pointer10[step10], pointer11 = &pointer11[step11], pointer12 = &pointer12[step12], pointer13 = &pointer13[step13], pointer14 = &pointer14[step14])
-            callback(new Entity(it.Handle->world, it.Handle->entities[i]), (T0*)pointer0, (T1*)pointer1, (T2*)pointer2, (T3*)pointer3, (T4*)pointer4, (T5*)pointer5, (T6*)pointer6, (T7*)pointer7, (T8*)pointer8, (T9*)pointer9, (T10*)pointer10, (T11*)pointer11, (T12*)pointer12, (T13*)pointer13, (T14*)pointer14);
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>() || RuntimeHelpers.IsReferenceOrContainsReferences<T9>() || RuntimeHelpers.IsReferenceOrContainsReferences<T10>() || RuntimeHelpers.IsReferenceOrContainsReferences<T11>() || RuntimeHelpers.IsReferenceOrContainsReferences<T12>() || RuntimeHelpers.IsReferenceOrContainsReferences<T13>() || RuntimeHelpers.IsReferenceOrContainsReferences<T14>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, T14*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerUnmanaged(i), field1.PointerUnmanaged(i), field2.PointerUnmanaged(i), field3.PointerUnmanaged(i), field4.PointerUnmanaged(i), field5.PointerUnmanaged(i), field6.PointerUnmanaged(i), field7.PointerUnmanaged(i), field8.PointerUnmanaged(i), field9.PointerUnmanaged(i), field10.PointerUnmanaged(i), field11.PointerUnmanaged(i), field12.PointerUnmanaged(i), field13.PointerUnmanaged(i), field14.PointerUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, T14*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSharedUnmanaged(i), field1.PointerSharedUnmanaged(i), field2.PointerSharedUnmanaged(i), field3.PointerSharedUnmanaged(i), field4.PointerSharedUnmanaged(i), field5.PointerSharedUnmanaged(i), field6.PointerSharedUnmanaged(i), field7.PointerSharedUnmanaged(i), field8.PointerSharedUnmanaged(i), field9.PointerSharedUnmanaged(i), field10.PointerSharedUnmanaged(i), field11.PointerSharedUnmanaged(i), field12.PointerSharedUnmanaged(i), field13.PointerSharedUnmanaged(i), field14.PointerSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, T14*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseUnmanaged(i), field1.PointerSparseUnmanaged(i), field2.PointerSparseUnmanaged(i), field3.PointerSparseUnmanaged(i), field4.PointerSparseUnmanaged(i), field5.PointerSparseUnmanaged(i), field6.PointerSparseUnmanaged(i), field7.PointerSparseUnmanaged(i), field8.PointerSparseUnmanaged(i), field9.PointerSparseUnmanaged(i), field10.PointerSparseUnmanaged(i), field11.PointerSparseUnmanaged(i), field12.PointerSparseUnmanaged(i), field13.PointerSparseUnmanaged(i), field14.PointerSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, T14*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseSharedUnmanaged(i), field1.PointerSparseSharedUnmanaged(i), field2.PointerSparseSharedUnmanaged(i), field3.PointerSparseSharedUnmanaged(i), field4.PointerSparseSharedUnmanaged(i), field5.PointerSparseSharedUnmanaged(i), field6.PointerSparseSharedUnmanaged(i), field7.PointerSparseSharedUnmanaged(i), field8.PointerSparseSharedUnmanaged(i), field9.PointerSparseSharedUnmanaged(i), field10.PointerSparseSharedUnmanaged(i), field11.PointerSparseSharedUnmanaged(i), field12.PointerSparseSharedUnmanaged(i), field13.PointerSparseSharedUnmanaged(i), field14.PointerSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, T14*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerManaged(i), field1.PointerManaged(i), field2.PointerManaged(i), field3.PointerManaged(i), field4.PointerManaged(i), field5.PointerManaged(i), field6.PointerManaged(i), field7.PointerManaged(i), field8.PointerManaged(i), field9.PointerManaged(i), field10.PointerManaged(i), field11.PointerManaged(i), field12.PointerManaged(i), field13.PointerManaged(i), field14.PointerManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, T14*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSharedManaged(i), field1.PointerSharedManaged(i), field2.PointerSharedManaged(i), field3.PointerSharedManaged(i), field4.PointerSharedManaged(i), field5.PointerSharedManaged(i), field6.PointerSharedManaged(i), field7.PointerSharedManaged(i), field8.PointerSharedManaged(i), field9.PointerSharedManaged(i), field10.PointerSharedManaged(i), field11.PointerSharedManaged(i), field12.PointerSharedManaged(i), field13.PointerSharedManaged(i), field14.PointerSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, T14*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseManaged(i), field1.PointerSparseManaged(i), field2.PointerSparseManaged(i), field3.PointerSparseManaged(i), field4.PointerSparseManaged(i), field5.PointerSparseManaged(i), field6.PointerSparseManaged(i), field7.PointerSparseManaged(i), field8.PointerSparseManaged(i), field9.PointerSparseManaged(i), field10.PointerSparseManaged(i), field11.PointerSparseManaged(i), field12.PointerSparseManaged(i), field13.PointerSparseManaged(i), field14.PointerSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, T14*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseSharedManaged(i), field1.PointerSparseSharedManaged(i), field2.PointerSparseSharedManaged(i), field3.PointerSparseSharedManaged(i), field4.PointerSparseSharedManaged(i), field5.PointerSparseSharedManaged(i), field6.PointerSparseSharedManaged(i), field7.PointerSparseSharedManaged(i), field8.PointerSparseSharedManaged(i), field9.PointerSparseSharedManaged(i), field10.PointerSparseSharedManaged(i), field11.PointerSparseSharedManaged(i), field12.PointerSparseSharedManaged(i), field13.PointerSparseSharedManaged(i), field14.PointerSparseSharedManaged(i));
+        }
     }
 
     /// <summary>
@@ -248,14 +1108,92 @@ public static void Each<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8); byte* pointer9 = (byte*)it.GetPointer<T9>(9); byte* pointer10 = (byte*)it.GetPointer<T10>(10); byte* pointer11 = (byte*)it.GetPointer<T11>(11); byte* pointer12 = (byte*)it.GetPointer<T12>(12); byte* pointer13 = (byte*)it.GetPointer<T13>(13); byte* pointer14 = (byte*)it.GetPointer<T14>(14);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8); int step9 = it.Step<T9>(9); int step10 = it.Step<T10>(10); int step11 = it.Step<T11>(11); int step12 = it.Step<T12>(12); int step13 = it.Step<T13>(13); int step14 = it.Step<T14>(14);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8); FieldData<T9> field9 = it.GetFieldData<T9>(9); FieldData<T10> field10 = it.GetFieldData<T10>(10); FieldData<T11> field11 = it.GetFieldData<T11>(11); FieldData<T12> field12 = it.GetFieldData<T12>(12); FieldData<T13> field13 = it.GetFieldData<T13>(13); FieldData<T14> field14 = it.GetFieldData<T14>(14);
+        IterationTechnique flags = it.GetIterationTechnique(15);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8], pointer9 = &pointer9[step9], pointer10 = &pointer10[step10], pointer11 = &pointer11[step11], pointer12 = &pointer12[step12], pointer13 = &pointer13[step13], pointer14 = &pointer14[step14])
-            callback(it, i, (T0*)pointer0, (T1*)pointer1, (T2*)pointer2, (T3*)pointer3, (T4*)pointer4, (T5*)pointer5, (T6*)pointer6, (T7*)pointer7, (T8*)pointer8, (T9*)pointer9, (T10*)pointer10, (T11*)pointer11, (T12*)pointer12, (T13*)pointer13, (T14*)pointer14);
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>() || RuntimeHelpers.IsReferenceOrContainsReferences<T9>() || RuntimeHelpers.IsReferenceOrContainsReferences<T10>() || RuntimeHelpers.IsReferenceOrContainsReferences<T11>() || RuntimeHelpers.IsReferenceOrContainsReferences<T12>() || RuntimeHelpers.IsReferenceOrContainsReferences<T13>() || RuntimeHelpers.IsReferenceOrContainsReferences<T14>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, T14*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerUnmanaged(i), field1.PointerUnmanaged(i), field2.PointerUnmanaged(i), field3.PointerUnmanaged(i), field4.PointerUnmanaged(i), field5.PointerUnmanaged(i), field6.PointerUnmanaged(i), field7.PointerUnmanaged(i), field8.PointerUnmanaged(i), field9.PointerUnmanaged(i), field10.PointerUnmanaged(i), field11.PointerUnmanaged(i), field12.PointerUnmanaged(i), field13.PointerUnmanaged(i), field14.PointerUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, T14*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSharedUnmanaged(i), field1.PointerSharedUnmanaged(i), field2.PointerSharedUnmanaged(i), field3.PointerSharedUnmanaged(i), field4.PointerSharedUnmanaged(i), field5.PointerSharedUnmanaged(i), field6.PointerSharedUnmanaged(i), field7.PointerSharedUnmanaged(i), field8.PointerSharedUnmanaged(i), field9.PointerSharedUnmanaged(i), field10.PointerSharedUnmanaged(i), field11.PointerSharedUnmanaged(i), field12.PointerSharedUnmanaged(i), field13.PointerSharedUnmanaged(i), field14.PointerSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, T14*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSparseUnmanaged(i), field1.PointerSparseUnmanaged(i), field2.PointerSparseUnmanaged(i), field3.PointerSparseUnmanaged(i), field4.PointerSparseUnmanaged(i), field5.PointerSparseUnmanaged(i), field6.PointerSparseUnmanaged(i), field7.PointerSparseUnmanaged(i), field8.PointerSparseUnmanaged(i), field9.PointerSparseUnmanaged(i), field10.PointerSparseUnmanaged(i), field11.PointerSparseUnmanaged(i), field12.PointerSparseUnmanaged(i), field13.PointerSparseUnmanaged(i), field14.PointerSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, T14*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSparseSharedUnmanaged(i), field1.PointerSparseSharedUnmanaged(i), field2.PointerSparseSharedUnmanaged(i), field3.PointerSparseSharedUnmanaged(i), field4.PointerSparseSharedUnmanaged(i), field5.PointerSparseSharedUnmanaged(i), field6.PointerSparseSharedUnmanaged(i), field7.PointerSparseSharedUnmanaged(i), field8.PointerSparseSharedUnmanaged(i), field9.PointerSparseSharedUnmanaged(i), field10.PointerSparseSharedUnmanaged(i), field11.PointerSparseSharedUnmanaged(i), field12.PointerSparseSharedUnmanaged(i), field13.PointerSparseSharedUnmanaged(i), field14.PointerSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, T14*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerManaged(i), field1.PointerManaged(i), field2.PointerManaged(i), field3.PointerManaged(i), field4.PointerManaged(i), field5.PointerManaged(i), field6.PointerManaged(i), field7.PointerManaged(i), field8.PointerManaged(i), field9.PointerManaged(i), field10.PointerManaged(i), field11.PointerManaged(i), field12.PointerManaged(i), field13.PointerManaged(i), field14.PointerManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, T14*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSharedManaged(i), field1.PointerSharedManaged(i), field2.PointerSharedManaged(i), field3.PointerSharedManaged(i), field4.PointerSharedManaged(i), field5.PointerSharedManaged(i), field6.PointerSharedManaged(i), field7.PointerSharedManaged(i), field8.PointerSharedManaged(i), field9.PointerSharedManaged(i), field10.PointerSharedManaged(i), field11.PointerSharedManaged(i), field12.PointerSharedManaged(i), field13.PointerSharedManaged(i), field14.PointerSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, T14*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSparseManaged(i), field1.PointerSparseManaged(i), field2.PointerSparseManaged(i), field3.PointerSparseManaged(i), field4.PointerSparseManaged(i), field5.PointerSparseManaged(i), field6.PointerSparseManaged(i), field7.PointerSparseManaged(i), field8.PointerSparseManaged(i), field9.PointerSparseManaged(i), field10.PointerSparseManaged(i), field11.PointerSparseManaged(i), field12.PointerSparseManaged(i), field13.PointerSparseManaged(i), field14.PointerSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, T14*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSparseSharedManaged(i), field1.PointerSparseSharedManaged(i), field2.PointerSparseSharedManaged(i), field3.PointerSparseSharedManaged(i), field4.PointerSparseSharedManaged(i), field5.PointerSparseSharedManaged(i), field6.PointerSparseSharedManaged(i), field7.PointerSparseSharedManaged(i), field8.PointerSparseSharedManaged(i), field9.PointerSparseSharedManaged(i), field10.PointerSparseSharedManaged(i), field11.PointerSparseSharedManaged(i), field12.PointerSparseSharedManaged(i), field13.PointerSparseSharedManaged(i), field14.PointerSparseSharedManaged(i));
+        }
     }
 }
\ No newline at end of file
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/Invoker/Each/Iterator/T16.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/Invoker/Each/Iterator/T16.g.cs
index 27139a45..e4fa177a 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/Invoker/Each/Iterator/T16.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/Invoker/Each/Iterator/T16.g.cs
@@ -1,5 +1,7 @@
 // Each/Iterator/T16.g.cs
 // File was auto-generated by /_/src/Flecs.NET.Codegen/Generators/Invoker.cs
+using System;
+using System.Runtime.CompilerServices;
 using Flecs.NET.Utilities;
 using static Flecs.NET.Bindings.flecs;
 
@@ -17,15 +19,93 @@ public static void Each<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8); byte* pointer9 = (byte*)it.GetPointer<T9>(9); byte* pointer10 = (byte*)it.GetPointer<T10>(10); byte* pointer11 = (byte*)it.GetPointer<T11>(11); byte* pointer12 = (byte*)it.GetPointer<T12>(12); byte* pointer13 = (byte*)it.GetPointer<T13>(13); byte* pointer14 = (byte*)it.GetPointer<T14>(14); byte* pointer15 = (byte*)it.GetPointer<T15>(15);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8); int step9 = it.Step<T9>(9); int step10 = it.Step<T10>(10); int step11 = it.Step<T11>(11); int step12 = it.Step<T12>(12); int step13 = it.Step<T13>(13); int step14 = it.Step<T14>(14); int step15 = it.Step<T15>(15);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8); FieldData<T9> field9 = it.GetFieldData<T9>(9); FieldData<T10> field10 = it.GetFieldData<T10>(10); FieldData<T11> field11 = it.GetFieldData<T11>(11); FieldData<T12> field12 = it.GetFieldData<T12>(12); FieldData<T13> field13 = it.GetFieldData<T13>(13); FieldData<T14> field14 = it.GetFieldData<T14>(14); FieldData<T15> field15 = it.GetFieldData<T15>(15);
+        IterationTechnique flags = it.GetIterationTechnique(16);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8], pointer9 = &pointer9[step9], pointer10 = &pointer10[step10], pointer11 = &pointer11[step11], pointer12 = &pointer12[step12], pointer13 = &pointer13[step13], pointer14 = &pointer14[step14], pointer15 = &pointer15[step15])
-            callback(ref Managed.GetTypeRef<T0>(pointer0), ref Managed.GetTypeRef<T1>(pointer1), ref Managed.GetTypeRef<T2>(pointer2), ref Managed.GetTypeRef<T3>(pointer3), ref Managed.GetTypeRef<T4>(pointer4), ref Managed.GetTypeRef<T5>(pointer5), ref Managed.GetTypeRef<T6>(pointer6), ref Managed.GetTypeRef<T7>(pointer7), ref Managed.GetTypeRef<T8>(pointer8), ref Managed.GetTypeRef<T9>(pointer9), ref Managed.GetTypeRef<T10>(pointer10), ref Managed.GetTypeRef<T11>(pointer11), ref Managed.GetTypeRef<T12>(pointer12), ref Managed.GetTypeRef<T13>(pointer13), ref Managed.GetTypeRef<T14>(pointer14), ref Managed.GetTypeRef<T15>(pointer15));
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>() || RuntimeHelpers.IsReferenceOrContainsReferences<T9>() || RuntimeHelpers.IsReferenceOrContainsReferences<T10>() || RuntimeHelpers.IsReferenceOrContainsReferences<T11>() || RuntimeHelpers.IsReferenceOrContainsReferences<T12>() || RuntimeHelpers.IsReferenceOrContainsReferences<T13>() || RuntimeHelpers.IsReferenceOrContainsReferences<T14>() || RuntimeHelpers.IsReferenceOrContainsReferences<T15>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefUnmanaged(i), ref field1.RefUnmanaged(i), ref field2.RefUnmanaged(i), ref field3.RefUnmanaged(i), ref field4.RefUnmanaged(i), ref field5.RefUnmanaged(i), ref field6.RefUnmanaged(i), ref field7.RefUnmanaged(i), ref field8.RefUnmanaged(i), ref field9.RefUnmanaged(i), ref field10.RefUnmanaged(i), ref field11.RefUnmanaged(i), ref field12.RefUnmanaged(i), ref field13.RefUnmanaged(i), ref field14.RefUnmanaged(i), ref field15.RefUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSharedUnmanaged(i), ref field1.RefSharedUnmanaged(i), ref field2.RefSharedUnmanaged(i), ref field3.RefSharedUnmanaged(i), ref field4.RefSharedUnmanaged(i), ref field5.RefSharedUnmanaged(i), ref field6.RefSharedUnmanaged(i), ref field7.RefSharedUnmanaged(i), ref field8.RefSharedUnmanaged(i), ref field9.RefSharedUnmanaged(i), ref field10.RefSharedUnmanaged(i), ref field11.RefSharedUnmanaged(i), ref field12.RefSharedUnmanaged(i), ref field13.RefSharedUnmanaged(i), ref field14.RefSharedUnmanaged(i), ref field15.RefSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSparseUnmanaged(i), ref field1.RefSparseUnmanaged(i), ref field2.RefSparseUnmanaged(i), ref field3.RefSparseUnmanaged(i), ref field4.RefSparseUnmanaged(i), ref field5.RefSparseUnmanaged(i), ref field6.RefSparseUnmanaged(i), ref field7.RefSparseUnmanaged(i), ref field8.RefSparseUnmanaged(i), ref field9.RefSparseUnmanaged(i), ref field10.RefSparseUnmanaged(i), ref field11.RefSparseUnmanaged(i), ref field12.RefSparseUnmanaged(i), ref field13.RefSparseUnmanaged(i), ref field14.RefSparseUnmanaged(i), ref field15.RefSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSparseSharedUnmanaged(i), ref field1.RefSparseSharedUnmanaged(i), ref field2.RefSparseSharedUnmanaged(i), ref field3.RefSparseSharedUnmanaged(i), ref field4.RefSparseSharedUnmanaged(i), ref field5.RefSparseSharedUnmanaged(i), ref field6.RefSparseSharedUnmanaged(i), ref field7.RefSparseSharedUnmanaged(i), ref field8.RefSparseSharedUnmanaged(i), ref field9.RefSparseSharedUnmanaged(i), ref field10.RefSparseSharedUnmanaged(i), ref field11.RefSparseSharedUnmanaged(i), ref field12.RefSparseSharedUnmanaged(i), ref field13.RefSparseSharedUnmanaged(i), ref field14.RefSparseSharedUnmanaged(i), ref field15.RefSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefManaged(i), ref field1.RefManaged(i), ref field2.RefManaged(i), ref field3.RefManaged(i), ref field4.RefManaged(i), ref field5.RefManaged(i), ref field6.RefManaged(i), ref field7.RefManaged(i), ref field8.RefManaged(i), ref field9.RefManaged(i), ref field10.RefManaged(i), ref field11.RefManaged(i), ref field12.RefManaged(i), ref field13.RefManaged(i), ref field14.RefManaged(i), ref field15.RefManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSharedManaged(i), ref field1.RefSharedManaged(i), ref field2.RefSharedManaged(i), ref field3.RefSharedManaged(i), ref field4.RefSharedManaged(i), ref field5.RefSharedManaged(i), ref field6.RefSharedManaged(i), ref field7.RefSharedManaged(i), ref field8.RefSharedManaged(i), ref field9.RefSharedManaged(i), ref field10.RefSharedManaged(i), ref field11.RefSharedManaged(i), ref field12.RefSharedManaged(i), ref field13.RefSharedManaged(i), ref field14.RefSharedManaged(i), ref field15.RefSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSparseManaged(i), ref field1.RefSparseManaged(i), ref field2.RefSparseManaged(i), ref field3.RefSparseManaged(i), ref field4.RefSparseManaged(i), ref field5.RefSparseManaged(i), ref field6.RefSparseManaged(i), ref field7.RefSparseManaged(i), ref field8.RefSparseManaged(i), ref field9.RefSparseManaged(i), ref field10.RefSparseManaged(i), ref field11.RefSparseManaged(i), ref field12.RefSparseManaged(i), ref field13.RefSparseManaged(i), ref field14.RefSparseManaged(i), ref field15.RefSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSparseSharedManaged(i), ref field1.RefSparseSharedManaged(i), ref field2.RefSparseSharedManaged(i), ref field3.RefSparseSharedManaged(i), ref field4.RefSparseSharedManaged(i), ref field5.RefSparseSharedManaged(i), ref field6.RefSparseSharedManaged(i), ref field7.RefSparseSharedManaged(i), ref field8.RefSparseSharedManaged(i), ref field9.RefSparseSharedManaged(i), ref field10.RefSparseSharedManaged(i), ref field11.RefSparseSharedManaged(i), ref field12.RefSparseSharedManaged(i), ref field13.RefSparseSharedManaged(i), ref field14.RefSparseSharedManaged(i), ref field15.RefSparseSharedManaged(i));
+        }
     }
 
     /// <summary>
@@ -38,15 +118,93 @@ public static void Each<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T
     {
         int count = it.Handle->count; Ecs.Assert(it.Handle->count > 0, "No entities returned, use Iter() or Each() without the entity argument instead.");
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8); byte* pointer9 = (byte*)it.GetPointer<T9>(9); byte* pointer10 = (byte*)it.GetPointer<T10>(10); byte* pointer11 = (byte*)it.GetPointer<T11>(11); byte* pointer12 = (byte*)it.GetPointer<T12>(12); byte* pointer13 = (byte*)it.GetPointer<T13>(13); byte* pointer14 = (byte*)it.GetPointer<T14>(14); byte* pointer15 = (byte*)it.GetPointer<T15>(15);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8); int step9 = it.Step<T9>(9); int step10 = it.Step<T10>(10); int step11 = it.Step<T11>(11); int step12 = it.Step<T12>(12); int step13 = it.Step<T13>(13); int step14 = it.Step<T14>(14); int step15 = it.Step<T15>(15);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8); FieldData<T9> field9 = it.GetFieldData<T9>(9); FieldData<T10> field10 = it.GetFieldData<T10>(10); FieldData<T11> field11 = it.GetFieldData<T11>(11); FieldData<T12> field12 = it.GetFieldData<T12>(12); FieldData<T13> field13 = it.GetFieldData<T13>(13); FieldData<T14> field14 = it.GetFieldData<T14>(14); FieldData<T15> field15 = it.GetFieldData<T15>(15);
+        IterationTechnique flags = it.GetIterationTechnique(16);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8], pointer9 = &pointer9[step9], pointer10 = &pointer10[step10], pointer11 = &pointer11[step11], pointer12 = &pointer12[step12], pointer13 = &pointer13[step13], pointer14 = &pointer14[step14], pointer15 = &pointer15[step15])
-            callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref Managed.GetTypeRef<T0>(pointer0), ref Managed.GetTypeRef<T1>(pointer1), ref Managed.GetTypeRef<T2>(pointer2), ref Managed.GetTypeRef<T3>(pointer3), ref Managed.GetTypeRef<T4>(pointer4), ref Managed.GetTypeRef<T5>(pointer5), ref Managed.GetTypeRef<T6>(pointer6), ref Managed.GetTypeRef<T7>(pointer7), ref Managed.GetTypeRef<T8>(pointer8), ref Managed.GetTypeRef<T9>(pointer9), ref Managed.GetTypeRef<T10>(pointer10), ref Managed.GetTypeRef<T11>(pointer11), ref Managed.GetTypeRef<T12>(pointer12), ref Managed.GetTypeRef<T13>(pointer13), ref Managed.GetTypeRef<T14>(pointer14), ref Managed.GetTypeRef<T15>(pointer15));
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>() || RuntimeHelpers.IsReferenceOrContainsReferences<T9>() || RuntimeHelpers.IsReferenceOrContainsReferences<T10>() || RuntimeHelpers.IsReferenceOrContainsReferences<T11>() || RuntimeHelpers.IsReferenceOrContainsReferences<T12>() || RuntimeHelpers.IsReferenceOrContainsReferences<T13>() || RuntimeHelpers.IsReferenceOrContainsReferences<T14>() || RuntimeHelpers.IsReferenceOrContainsReferences<T15>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefUnmanaged(i), ref field1.RefUnmanaged(i), ref field2.RefUnmanaged(i), ref field3.RefUnmanaged(i), ref field4.RefUnmanaged(i), ref field5.RefUnmanaged(i), ref field6.RefUnmanaged(i), ref field7.RefUnmanaged(i), ref field8.RefUnmanaged(i), ref field9.RefUnmanaged(i), ref field10.RefUnmanaged(i), ref field11.RefUnmanaged(i), ref field12.RefUnmanaged(i), ref field13.RefUnmanaged(i), ref field14.RefUnmanaged(i), ref field15.RefUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSharedUnmanaged(i), ref field1.RefSharedUnmanaged(i), ref field2.RefSharedUnmanaged(i), ref field3.RefSharedUnmanaged(i), ref field4.RefSharedUnmanaged(i), ref field5.RefSharedUnmanaged(i), ref field6.RefSharedUnmanaged(i), ref field7.RefSharedUnmanaged(i), ref field8.RefSharedUnmanaged(i), ref field9.RefSharedUnmanaged(i), ref field10.RefSharedUnmanaged(i), ref field11.RefSharedUnmanaged(i), ref field12.RefSharedUnmanaged(i), ref field13.RefSharedUnmanaged(i), ref field14.RefSharedUnmanaged(i), ref field15.RefSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseUnmanaged(i), ref field1.RefSparseUnmanaged(i), ref field2.RefSparseUnmanaged(i), ref field3.RefSparseUnmanaged(i), ref field4.RefSparseUnmanaged(i), ref field5.RefSparseUnmanaged(i), ref field6.RefSparseUnmanaged(i), ref field7.RefSparseUnmanaged(i), ref field8.RefSparseUnmanaged(i), ref field9.RefSparseUnmanaged(i), ref field10.RefSparseUnmanaged(i), ref field11.RefSparseUnmanaged(i), ref field12.RefSparseUnmanaged(i), ref field13.RefSparseUnmanaged(i), ref field14.RefSparseUnmanaged(i), ref field15.RefSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseSharedUnmanaged(i), ref field1.RefSparseSharedUnmanaged(i), ref field2.RefSparseSharedUnmanaged(i), ref field3.RefSparseSharedUnmanaged(i), ref field4.RefSparseSharedUnmanaged(i), ref field5.RefSparseSharedUnmanaged(i), ref field6.RefSparseSharedUnmanaged(i), ref field7.RefSparseSharedUnmanaged(i), ref field8.RefSparseSharedUnmanaged(i), ref field9.RefSparseSharedUnmanaged(i), ref field10.RefSparseSharedUnmanaged(i), ref field11.RefSparseSharedUnmanaged(i), ref field12.RefSparseSharedUnmanaged(i), ref field13.RefSparseSharedUnmanaged(i), ref field14.RefSparseSharedUnmanaged(i), ref field15.RefSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefManaged(i), ref field1.RefManaged(i), ref field2.RefManaged(i), ref field3.RefManaged(i), ref field4.RefManaged(i), ref field5.RefManaged(i), ref field6.RefManaged(i), ref field7.RefManaged(i), ref field8.RefManaged(i), ref field9.RefManaged(i), ref field10.RefManaged(i), ref field11.RefManaged(i), ref field12.RefManaged(i), ref field13.RefManaged(i), ref field14.RefManaged(i), ref field15.RefManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSharedManaged(i), ref field1.RefSharedManaged(i), ref field2.RefSharedManaged(i), ref field3.RefSharedManaged(i), ref field4.RefSharedManaged(i), ref field5.RefSharedManaged(i), ref field6.RefSharedManaged(i), ref field7.RefSharedManaged(i), ref field8.RefSharedManaged(i), ref field9.RefSharedManaged(i), ref field10.RefSharedManaged(i), ref field11.RefSharedManaged(i), ref field12.RefSharedManaged(i), ref field13.RefSharedManaged(i), ref field14.RefSharedManaged(i), ref field15.RefSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseManaged(i), ref field1.RefSparseManaged(i), ref field2.RefSparseManaged(i), ref field3.RefSparseManaged(i), ref field4.RefSparseManaged(i), ref field5.RefSparseManaged(i), ref field6.RefSparseManaged(i), ref field7.RefSparseManaged(i), ref field8.RefSparseManaged(i), ref field9.RefSparseManaged(i), ref field10.RefSparseManaged(i), ref field11.RefSparseManaged(i), ref field12.RefSparseManaged(i), ref field13.RefSparseManaged(i), ref field14.RefSparseManaged(i), ref field15.RefSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseSharedManaged(i), ref field1.RefSparseSharedManaged(i), ref field2.RefSparseSharedManaged(i), ref field3.RefSparseSharedManaged(i), ref field4.RefSparseSharedManaged(i), ref field5.RefSparseSharedManaged(i), ref field6.RefSparseSharedManaged(i), ref field7.RefSparseSharedManaged(i), ref field8.RefSparseSharedManaged(i), ref field9.RefSparseSharedManaged(i), ref field10.RefSparseSharedManaged(i), ref field11.RefSparseSharedManaged(i), ref field12.RefSparseSharedManaged(i), ref field13.RefSparseSharedManaged(i), ref field14.RefSparseSharedManaged(i), ref field15.RefSparseSharedManaged(i));
+        }
     }
 
     /// <summary>
@@ -59,15 +217,93 @@ public static void Each<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8); byte* pointer9 = (byte*)it.GetPointer<T9>(9); byte* pointer10 = (byte*)it.GetPointer<T10>(10); byte* pointer11 = (byte*)it.GetPointer<T11>(11); byte* pointer12 = (byte*)it.GetPointer<T12>(12); byte* pointer13 = (byte*)it.GetPointer<T13>(13); byte* pointer14 = (byte*)it.GetPointer<T14>(14); byte* pointer15 = (byte*)it.GetPointer<T15>(15);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8); int step9 = it.Step<T9>(9); int step10 = it.Step<T10>(10); int step11 = it.Step<T11>(11); int step12 = it.Step<T12>(12); int step13 = it.Step<T13>(13); int step14 = it.Step<T14>(14); int step15 = it.Step<T15>(15);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8); FieldData<T9> field9 = it.GetFieldData<T9>(9); FieldData<T10> field10 = it.GetFieldData<T10>(10); FieldData<T11> field11 = it.GetFieldData<T11>(11); FieldData<T12> field12 = it.GetFieldData<T12>(12); FieldData<T13> field13 = it.GetFieldData<T13>(13); FieldData<T14> field14 = it.GetFieldData<T14>(14); FieldData<T15> field15 = it.GetFieldData<T15>(15);
+        IterationTechnique flags = it.GetIterationTechnique(16);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8], pointer9 = &pointer9[step9], pointer10 = &pointer10[step10], pointer11 = &pointer11[step11], pointer12 = &pointer12[step12], pointer13 = &pointer13[step13], pointer14 = &pointer14[step14], pointer15 = &pointer15[step15])
-            callback(it, i, ref Managed.GetTypeRef<T0>(pointer0), ref Managed.GetTypeRef<T1>(pointer1), ref Managed.GetTypeRef<T2>(pointer2), ref Managed.GetTypeRef<T3>(pointer3), ref Managed.GetTypeRef<T4>(pointer4), ref Managed.GetTypeRef<T5>(pointer5), ref Managed.GetTypeRef<T6>(pointer6), ref Managed.GetTypeRef<T7>(pointer7), ref Managed.GetTypeRef<T8>(pointer8), ref Managed.GetTypeRef<T9>(pointer9), ref Managed.GetTypeRef<T10>(pointer10), ref Managed.GetTypeRef<T11>(pointer11), ref Managed.GetTypeRef<T12>(pointer12), ref Managed.GetTypeRef<T13>(pointer13), ref Managed.GetTypeRef<T14>(pointer14), ref Managed.GetTypeRef<T15>(pointer15));
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>() || RuntimeHelpers.IsReferenceOrContainsReferences<T9>() || RuntimeHelpers.IsReferenceOrContainsReferences<T10>() || RuntimeHelpers.IsReferenceOrContainsReferences<T11>() || RuntimeHelpers.IsReferenceOrContainsReferences<T12>() || RuntimeHelpers.IsReferenceOrContainsReferences<T13>() || RuntimeHelpers.IsReferenceOrContainsReferences<T14>() || RuntimeHelpers.IsReferenceOrContainsReferences<T15>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefUnmanaged(i), ref field1.RefUnmanaged(i), ref field2.RefUnmanaged(i), ref field3.RefUnmanaged(i), ref field4.RefUnmanaged(i), ref field5.RefUnmanaged(i), ref field6.RefUnmanaged(i), ref field7.RefUnmanaged(i), ref field8.RefUnmanaged(i), ref field9.RefUnmanaged(i), ref field10.RefUnmanaged(i), ref field11.RefUnmanaged(i), ref field12.RefUnmanaged(i), ref field13.RefUnmanaged(i), ref field14.RefUnmanaged(i), ref field15.RefUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSharedUnmanaged(i), ref field1.RefSharedUnmanaged(i), ref field2.RefSharedUnmanaged(i), ref field3.RefSharedUnmanaged(i), ref field4.RefSharedUnmanaged(i), ref field5.RefSharedUnmanaged(i), ref field6.RefSharedUnmanaged(i), ref field7.RefSharedUnmanaged(i), ref field8.RefSharedUnmanaged(i), ref field9.RefSharedUnmanaged(i), ref field10.RefSharedUnmanaged(i), ref field11.RefSharedUnmanaged(i), ref field12.RefSharedUnmanaged(i), ref field13.RefSharedUnmanaged(i), ref field14.RefSharedUnmanaged(i), ref field15.RefSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSparseUnmanaged(i), ref field1.RefSparseUnmanaged(i), ref field2.RefSparseUnmanaged(i), ref field3.RefSparseUnmanaged(i), ref field4.RefSparseUnmanaged(i), ref field5.RefSparseUnmanaged(i), ref field6.RefSparseUnmanaged(i), ref field7.RefSparseUnmanaged(i), ref field8.RefSparseUnmanaged(i), ref field9.RefSparseUnmanaged(i), ref field10.RefSparseUnmanaged(i), ref field11.RefSparseUnmanaged(i), ref field12.RefSparseUnmanaged(i), ref field13.RefSparseUnmanaged(i), ref field14.RefSparseUnmanaged(i), ref field15.RefSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSparseSharedUnmanaged(i), ref field1.RefSparseSharedUnmanaged(i), ref field2.RefSparseSharedUnmanaged(i), ref field3.RefSparseSharedUnmanaged(i), ref field4.RefSparseSharedUnmanaged(i), ref field5.RefSparseSharedUnmanaged(i), ref field6.RefSparseSharedUnmanaged(i), ref field7.RefSparseSharedUnmanaged(i), ref field8.RefSparseSharedUnmanaged(i), ref field9.RefSparseSharedUnmanaged(i), ref field10.RefSparseSharedUnmanaged(i), ref field11.RefSparseSharedUnmanaged(i), ref field12.RefSparseSharedUnmanaged(i), ref field13.RefSparseSharedUnmanaged(i), ref field14.RefSparseSharedUnmanaged(i), ref field15.RefSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefManaged(i), ref field1.RefManaged(i), ref field2.RefManaged(i), ref field3.RefManaged(i), ref field4.RefManaged(i), ref field5.RefManaged(i), ref field6.RefManaged(i), ref field7.RefManaged(i), ref field8.RefManaged(i), ref field9.RefManaged(i), ref field10.RefManaged(i), ref field11.RefManaged(i), ref field12.RefManaged(i), ref field13.RefManaged(i), ref field14.RefManaged(i), ref field15.RefManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSharedManaged(i), ref field1.RefSharedManaged(i), ref field2.RefSharedManaged(i), ref field3.RefSharedManaged(i), ref field4.RefSharedManaged(i), ref field5.RefSharedManaged(i), ref field6.RefSharedManaged(i), ref field7.RefSharedManaged(i), ref field8.RefSharedManaged(i), ref field9.RefSharedManaged(i), ref field10.RefSharedManaged(i), ref field11.RefSharedManaged(i), ref field12.RefSharedManaged(i), ref field13.RefSharedManaged(i), ref field14.RefSharedManaged(i), ref field15.RefSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSparseManaged(i), ref field1.RefSparseManaged(i), ref field2.RefSparseManaged(i), ref field3.RefSparseManaged(i), ref field4.RefSparseManaged(i), ref field5.RefSparseManaged(i), ref field6.RefSparseManaged(i), ref field7.RefSparseManaged(i), ref field8.RefSparseManaged(i), ref field9.RefSparseManaged(i), ref field10.RefSparseManaged(i), ref field11.RefSparseManaged(i), ref field12.RefSparseManaged(i), ref field13.RefSparseManaged(i), ref field14.RefSparseManaged(i), ref field15.RefSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSparseSharedManaged(i), ref field1.RefSparseSharedManaged(i), ref field2.RefSparseSharedManaged(i), ref field3.RefSparseSharedManaged(i), ref field4.RefSparseSharedManaged(i), ref field5.RefSparseSharedManaged(i), ref field6.RefSparseSharedManaged(i), ref field7.RefSparseSharedManaged(i), ref field8.RefSparseSharedManaged(i), ref field9.RefSparseSharedManaged(i), ref field10.RefSparseSharedManaged(i), ref field11.RefSparseSharedManaged(i), ref field12.RefSparseSharedManaged(i), ref field13.RefSparseSharedManaged(i), ref field14.RefSparseSharedManaged(i), ref field15.RefSparseSharedManaged(i));
+        }
     }
 
     /// <summary>
@@ -80,15 +316,93 @@ public static void Each<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8); byte* pointer9 = (byte*)it.GetPointer<T9>(9); byte* pointer10 = (byte*)it.GetPointer<T10>(10); byte* pointer11 = (byte*)it.GetPointer<T11>(11); byte* pointer12 = (byte*)it.GetPointer<T12>(12); byte* pointer13 = (byte*)it.GetPointer<T13>(13); byte* pointer14 = (byte*)it.GetPointer<T14>(14); byte* pointer15 = (byte*)it.GetPointer<T15>(15);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8); int step9 = it.Step<T9>(9); int step10 = it.Step<T10>(10); int step11 = it.Step<T11>(11); int step12 = it.Step<T12>(12); int step13 = it.Step<T13>(13); int step14 = it.Step<T14>(14); int step15 = it.Step<T15>(15);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8); FieldData<T9> field9 = it.GetFieldData<T9>(9); FieldData<T10> field10 = it.GetFieldData<T10>(10); FieldData<T11> field11 = it.GetFieldData<T11>(11); FieldData<T12> field12 = it.GetFieldData<T12>(12); FieldData<T13> field13 = it.GetFieldData<T13>(13); FieldData<T14> field14 = it.GetFieldData<T14>(14); FieldData<T15> field15 = it.GetFieldData<T15>(15);
+        IterationTechnique flags = it.GetIterationTechnique(16);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8], pointer9 = &pointer9[step9], pointer10 = &pointer10[step10], pointer11 = &pointer11[step11], pointer12 = &pointer12[step12], pointer13 = &pointer13[step13], pointer14 = &pointer14[step14], pointer15 = &pointer15[step15])
-            callback(ref Managed.GetTypeRef<T0>(pointer0), ref Managed.GetTypeRef<T1>(pointer1), ref Managed.GetTypeRef<T2>(pointer2), ref Managed.GetTypeRef<T3>(pointer3), ref Managed.GetTypeRef<T4>(pointer4), ref Managed.GetTypeRef<T5>(pointer5), ref Managed.GetTypeRef<T6>(pointer6), ref Managed.GetTypeRef<T7>(pointer7), ref Managed.GetTypeRef<T8>(pointer8), ref Managed.GetTypeRef<T9>(pointer9), ref Managed.GetTypeRef<T10>(pointer10), ref Managed.GetTypeRef<T11>(pointer11), ref Managed.GetTypeRef<T12>(pointer12), ref Managed.GetTypeRef<T13>(pointer13), ref Managed.GetTypeRef<T14>(pointer14), ref Managed.GetTypeRef<T15>(pointer15));
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>() || RuntimeHelpers.IsReferenceOrContainsReferences<T9>() || RuntimeHelpers.IsReferenceOrContainsReferences<T10>() || RuntimeHelpers.IsReferenceOrContainsReferences<T11>() || RuntimeHelpers.IsReferenceOrContainsReferences<T12>() || RuntimeHelpers.IsReferenceOrContainsReferences<T13>() || RuntimeHelpers.IsReferenceOrContainsReferences<T14>() || RuntimeHelpers.IsReferenceOrContainsReferences<T15>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, ref T14, ref T15, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefUnmanaged(i), ref field1.RefUnmanaged(i), ref field2.RefUnmanaged(i), ref field3.RefUnmanaged(i), ref field4.RefUnmanaged(i), ref field5.RefUnmanaged(i), ref field6.RefUnmanaged(i), ref field7.RefUnmanaged(i), ref field8.RefUnmanaged(i), ref field9.RefUnmanaged(i), ref field10.RefUnmanaged(i), ref field11.RefUnmanaged(i), ref field12.RefUnmanaged(i), ref field13.RefUnmanaged(i), ref field14.RefUnmanaged(i), ref field15.RefUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, ref T14, ref T15, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSharedUnmanaged(i), ref field1.RefSharedUnmanaged(i), ref field2.RefSharedUnmanaged(i), ref field3.RefSharedUnmanaged(i), ref field4.RefSharedUnmanaged(i), ref field5.RefSharedUnmanaged(i), ref field6.RefSharedUnmanaged(i), ref field7.RefSharedUnmanaged(i), ref field8.RefSharedUnmanaged(i), ref field9.RefSharedUnmanaged(i), ref field10.RefSharedUnmanaged(i), ref field11.RefSharedUnmanaged(i), ref field12.RefSharedUnmanaged(i), ref field13.RefSharedUnmanaged(i), ref field14.RefSharedUnmanaged(i), ref field15.RefSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, ref T14, ref T15, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSparseUnmanaged(i), ref field1.RefSparseUnmanaged(i), ref field2.RefSparseUnmanaged(i), ref field3.RefSparseUnmanaged(i), ref field4.RefSparseUnmanaged(i), ref field5.RefSparseUnmanaged(i), ref field6.RefSparseUnmanaged(i), ref field7.RefSparseUnmanaged(i), ref field8.RefSparseUnmanaged(i), ref field9.RefSparseUnmanaged(i), ref field10.RefSparseUnmanaged(i), ref field11.RefSparseUnmanaged(i), ref field12.RefSparseUnmanaged(i), ref field13.RefSparseUnmanaged(i), ref field14.RefSparseUnmanaged(i), ref field15.RefSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, ref T14, ref T15, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSparseSharedUnmanaged(i), ref field1.RefSparseSharedUnmanaged(i), ref field2.RefSparseSharedUnmanaged(i), ref field3.RefSparseSharedUnmanaged(i), ref field4.RefSparseSharedUnmanaged(i), ref field5.RefSparseSharedUnmanaged(i), ref field6.RefSparseSharedUnmanaged(i), ref field7.RefSparseSharedUnmanaged(i), ref field8.RefSparseSharedUnmanaged(i), ref field9.RefSparseSharedUnmanaged(i), ref field10.RefSparseSharedUnmanaged(i), ref field11.RefSparseSharedUnmanaged(i), ref field12.RefSparseSharedUnmanaged(i), ref field13.RefSparseSharedUnmanaged(i), ref field14.RefSparseSharedUnmanaged(i), ref field15.RefSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, ref T14, ref T15, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefManaged(i), ref field1.RefManaged(i), ref field2.RefManaged(i), ref field3.RefManaged(i), ref field4.RefManaged(i), ref field5.RefManaged(i), ref field6.RefManaged(i), ref field7.RefManaged(i), ref field8.RefManaged(i), ref field9.RefManaged(i), ref field10.RefManaged(i), ref field11.RefManaged(i), ref field12.RefManaged(i), ref field13.RefManaged(i), ref field14.RefManaged(i), ref field15.RefManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, ref T14, ref T15, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSharedManaged(i), ref field1.RefSharedManaged(i), ref field2.RefSharedManaged(i), ref field3.RefSharedManaged(i), ref field4.RefSharedManaged(i), ref field5.RefSharedManaged(i), ref field6.RefSharedManaged(i), ref field7.RefSharedManaged(i), ref field8.RefSharedManaged(i), ref field9.RefSharedManaged(i), ref field10.RefSharedManaged(i), ref field11.RefSharedManaged(i), ref field12.RefSharedManaged(i), ref field13.RefSharedManaged(i), ref field14.RefSharedManaged(i), ref field15.RefSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, ref T14, ref T15, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSparseManaged(i), ref field1.RefSparseManaged(i), ref field2.RefSparseManaged(i), ref field3.RefSparseManaged(i), ref field4.RefSparseManaged(i), ref field5.RefSparseManaged(i), ref field6.RefSparseManaged(i), ref field7.RefSparseManaged(i), ref field8.RefSparseManaged(i), ref field9.RefSparseManaged(i), ref field10.RefSparseManaged(i), ref field11.RefSparseManaged(i), ref field12.RefSparseManaged(i), ref field13.RefSparseManaged(i), ref field14.RefSparseManaged(i), ref field15.RefSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, ref T14, ref T15, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSparseSharedManaged(i), ref field1.RefSparseSharedManaged(i), ref field2.RefSparseSharedManaged(i), ref field3.RefSparseSharedManaged(i), ref field4.RefSparseSharedManaged(i), ref field5.RefSparseSharedManaged(i), ref field6.RefSparseSharedManaged(i), ref field7.RefSparseSharedManaged(i), ref field8.RefSparseSharedManaged(i), ref field9.RefSparseSharedManaged(i), ref field10.RefSparseSharedManaged(i), ref field11.RefSparseSharedManaged(i), ref field12.RefSparseSharedManaged(i), ref field13.RefSparseSharedManaged(i), ref field14.RefSparseSharedManaged(i), ref field15.RefSparseSharedManaged(i));
+        }
     }
 
     /// <summary>
@@ -101,15 +415,93 @@ public static void Each<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T
     {
         int count = it.Handle->count; Ecs.Assert(it.Handle->count > 0, "No entities returned, use Iter() or Each() without the entity argument instead.");
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8); byte* pointer9 = (byte*)it.GetPointer<T9>(9); byte* pointer10 = (byte*)it.GetPointer<T10>(10); byte* pointer11 = (byte*)it.GetPointer<T11>(11); byte* pointer12 = (byte*)it.GetPointer<T12>(12); byte* pointer13 = (byte*)it.GetPointer<T13>(13); byte* pointer14 = (byte*)it.GetPointer<T14>(14); byte* pointer15 = (byte*)it.GetPointer<T15>(15);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8); int step9 = it.Step<T9>(9); int step10 = it.Step<T10>(10); int step11 = it.Step<T11>(11); int step12 = it.Step<T12>(12); int step13 = it.Step<T13>(13); int step14 = it.Step<T14>(14); int step15 = it.Step<T15>(15);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8); FieldData<T9> field9 = it.GetFieldData<T9>(9); FieldData<T10> field10 = it.GetFieldData<T10>(10); FieldData<T11> field11 = it.GetFieldData<T11>(11); FieldData<T12> field12 = it.GetFieldData<T12>(12); FieldData<T13> field13 = it.GetFieldData<T13>(13); FieldData<T14> field14 = it.GetFieldData<T14>(14); FieldData<T15> field15 = it.GetFieldData<T15>(15);
+        IterationTechnique flags = it.GetIterationTechnique(16);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8], pointer9 = &pointer9[step9], pointer10 = &pointer10[step10], pointer11 = &pointer11[step11], pointer12 = &pointer12[step12], pointer13 = &pointer13[step13], pointer14 = &pointer14[step14], pointer15 = &pointer15[step15])
-            callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref Managed.GetTypeRef<T0>(pointer0), ref Managed.GetTypeRef<T1>(pointer1), ref Managed.GetTypeRef<T2>(pointer2), ref Managed.GetTypeRef<T3>(pointer3), ref Managed.GetTypeRef<T4>(pointer4), ref Managed.GetTypeRef<T5>(pointer5), ref Managed.GetTypeRef<T6>(pointer6), ref Managed.GetTypeRef<T7>(pointer7), ref Managed.GetTypeRef<T8>(pointer8), ref Managed.GetTypeRef<T9>(pointer9), ref Managed.GetTypeRef<T10>(pointer10), ref Managed.GetTypeRef<T11>(pointer11), ref Managed.GetTypeRef<T12>(pointer12), ref Managed.GetTypeRef<T13>(pointer13), ref Managed.GetTypeRef<T14>(pointer14), ref Managed.GetTypeRef<T15>(pointer15));
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>() || RuntimeHelpers.IsReferenceOrContainsReferences<T9>() || RuntimeHelpers.IsReferenceOrContainsReferences<T10>() || RuntimeHelpers.IsReferenceOrContainsReferences<T11>() || RuntimeHelpers.IsReferenceOrContainsReferences<T12>() || RuntimeHelpers.IsReferenceOrContainsReferences<T13>() || RuntimeHelpers.IsReferenceOrContainsReferences<T14>() || RuntimeHelpers.IsReferenceOrContainsReferences<T15>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, ref T14, ref T15, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefUnmanaged(i), ref field1.RefUnmanaged(i), ref field2.RefUnmanaged(i), ref field3.RefUnmanaged(i), ref field4.RefUnmanaged(i), ref field5.RefUnmanaged(i), ref field6.RefUnmanaged(i), ref field7.RefUnmanaged(i), ref field8.RefUnmanaged(i), ref field9.RefUnmanaged(i), ref field10.RefUnmanaged(i), ref field11.RefUnmanaged(i), ref field12.RefUnmanaged(i), ref field13.RefUnmanaged(i), ref field14.RefUnmanaged(i), ref field15.RefUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, ref T14, ref T15, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSharedUnmanaged(i), ref field1.RefSharedUnmanaged(i), ref field2.RefSharedUnmanaged(i), ref field3.RefSharedUnmanaged(i), ref field4.RefSharedUnmanaged(i), ref field5.RefSharedUnmanaged(i), ref field6.RefSharedUnmanaged(i), ref field7.RefSharedUnmanaged(i), ref field8.RefSharedUnmanaged(i), ref field9.RefSharedUnmanaged(i), ref field10.RefSharedUnmanaged(i), ref field11.RefSharedUnmanaged(i), ref field12.RefSharedUnmanaged(i), ref field13.RefSharedUnmanaged(i), ref field14.RefSharedUnmanaged(i), ref field15.RefSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, ref T14, ref T15, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseUnmanaged(i), ref field1.RefSparseUnmanaged(i), ref field2.RefSparseUnmanaged(i), ref field3.RefSparseUnmanaged(i), ref field4.RefSparseUnmanaged(i), ref field5.RefSparseUnmanaged(i), ref field6.RefSparseUnmanaged(i), ref field7.RefSparseUnmanaged(i), ref field8.RefSparseUnmanaged(i), ref field9.RefSparseUnmanaged(i), ref field10.RefSparseUnmanaged(i), ref field11.RefSparseUnmanaged(i), ref field12.RefSparseUnmanaged(i), ref field13.RefSparseUnmanaged(i), ref field14.RefSparseUnmanaged(i), ref field15.RefSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, ref T14, ref T15, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseSharedUnmanaged(i), ref field1.RefSparseSharedUnmanaged(i), ref field2.RefSparseSharedUnmanaged(i), ref field3.RefSparseSharedUnmanaged(i), ref field4.RefSparseSharedUnmanaged(i), ref field5.RefSparseSharedUnmanaged(i), ref field6.RefSparseSharedUnmanaged(i), ref field7.RefSparseSharedUnmanaged(i), ref field8.RefSparseSharedUnmanaged(i), ref field9.RefSparseSharedUnmanaged(i), ref field10.RefSparseSharedUnmanaged(i), ref field11.RefSparseSharedUnmanaged(i), ref field12.RefSparseSharedUnmanaged(i), ref field13.RefSparseSharedUnmanaged(i), ref field14.RefSparseSharedUnmanaged(i), ref field15.RefSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, ref T14, ref T15, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefManaged(i), ref field1.RefManaged(i), ref field2.RefManaged(i), ref field3.RefManaged(i), ref field4.RefManaged(i), ref field5.RefManaged(i), ref field6.RefManaged(i), ref field7.RefManaged(i), ref field8.RefManaged(i), ref field9.RefManaged(i), ref field10.RefManaged(i), ref field11.RefManaged(i), ref field12.RefManaged(i), ref field13.RefManaged(i), ref field14.RefManaged(i), ref field15.RefManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, ref T14, ref T15, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSharedManaged(i), ref field1.RefSharedManaged(i), ref field2.RefSharedManaged(i), ref field3.RefSharedManaged(i), ref field4.RefSharedManaged(i), ref field5.RefSharedManaged(i), ref field6.RefSharedManaged(i), ref field7.RefSharedManaged(i), ref field8.RefSharedManaged(i), ref field9.RefSharedManaged(i), ref field10.RefSharedManaged(i), ref field11.RefSharedManaged(i), ref field12.RefSharedManaged(i), ref field13.RefSharedManaged(i), ref field14.RefSharedManaged(i), ref field15.RefSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, ref T14, ref T15, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseManaged(i), ref field1.RefSparseManaged(i), ref field2.RefSparseManaged(i), ref field3.RefSparseManaged(i), ref field4.RefSparseManaged(i), ref field5.RefSparseManaged(i), ref field6.RefSparseManaged(i), ref field7.RefSparseManaged(i), ref field8.RefSparseManaged(i), ref field9.RefSparseManaged(i), ref field10.RefSparseManaged(i), ref field11.RefSparseManaged(i), ref field12.RefSparseManaged(i), ref field13.RefSparseManaged(i), ref field14.RefSparseManaged(i), ref field15.RefSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, ref T14, ref T15, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseSharedManaged(i), ref field1.RefSparseSharedManaged(i), ref field2.RefSparseSharedManaged(i), ref field3.RefSparseSharedManaged(i), ref field4.RefSparseSharedManaged(i), ref field5.RefSparseSharedManaged(i), ref field6.RefSparseSharedManaged(i), ref field7.RefSparseSharedManaged(i), ref field8.RefSparseSharedManaged(i), ref field9.RefSparseSharedManaged(i), ref field10.RefSparseSharedManaged(i), ref field11.RefSparseSharedManaged(i), ref field12.RefSparseSharedManaged(i), ref field13.RefSparseSharedManaged(i), ref field14.RefSparseSharedManaged(i), ref field15.RefSparseSharedManaged(i));
+        }
     }
 
     /// <summary>
@@ -122,15 +514,93 @@ public static void Each<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8); byte* pointer9 = (byte*)it.GetPointer<T9>(9); byte* pointer10 = (byte*)it.GetPointer<T10>(10); byte* pointer11 = (byte*)it.GetPointer<T11>(11); byte* pointer12 = (byte*)it.GetPointer<T12>(12); byte* pointer13 = (byte*)it.GetPointer<T13>(13); byte* pointer14 = (byte*)it.GetPointer<T14>(14); byte* pointer15 = (byte*)it.GetPointer<T15>(15);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8); int step9 = it.Step<T9>(9); int step10 = it.Step<T10>(10); int step11 = it.Step<T11>(11); int step12 = it.Step<T12>(12); int step13 = it.Step<T13>(13); int step14 = it.Step<T14>(14); int step15 = it.Step<T15>(15);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8); FieldData<T9> field9 = it.GetFieldData<T9>(9); FieldData<T10> field10 = it.GetFieldData<T10>(10); FieldData<T11> field11 = it.GetFieldData<T11>(11); FieldData<T12> field12 = it.GetFieldData<T12>(12); FieldData<T13> field13 = it.GetFieldData<T13>(13); FieldData<T14> field14 = it.GetFieldData<T14>(14); FieldData<T15> field15 = it.GetFieldData<T15>(15);
+        IterationTechnique flags = it.GetIterationTechnique(16);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8], pointer9 = &pointer9[step9], pointer10 = &pointer10[step10], pointer11 = &pointer11[step11], pointer12 = &pointer12[step12], pointer13 = &pointer13[step13], pointer14 = &pointer14[step14], pointer15 = &pointer15[step15])
-            callback(it, i, ref Managed.GetTypeRef<T0>(pointer0), ref Managed.GetTypeRef<T1>(pointer1), ref Managed.GetTypeRef<T2>(pointer2), ref Managed.GetTypeRef<T3>(pointer3), ref Managed.GetTypeRef<T4>(pointer4), ref Managed.GetTypeRef<T5>(pointer5), ref Managed.GetTypeRef<T6>(pointer6), ref Managed.GetTypeRef<T7>(pointer7), ref Managed.GetTypeRef<T8>(pointer8), ref Managed.GetTypeRef<T9>(pointer9), ref Managed.GetTypeRef<T10>(pointer10), ref Managed.GetTypeRef<T11>(pointer11), ref Managed.GetTypeRef<T12>(pointer12), ref Managed.GetTypeRef<T13>(pointer13), ref Managed.GetTypeRef<T14>(pointer14), ref Managed.GetTypeRef<T15>(pointer15));
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>() || RuntimeHelpers.IsReferenceOrContainsReferences<T9>() || RuntimeHelpers.IsReferenceOrContainsReferences<T10>() || RuntimeHelpers.IsReferenceOrContainsReferences<T11>() || RuntimeHelpers.IsReferenceOrContainsReferences<T12>() || RuntimeHelpers.IsReferenceOrContainsReferences<T13>() || RuntimeHelpers.IsReferenceOrContainsReferences<T14>() || RuntimeHelpers.IsReferenceOrContainsReferences<T15>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, ref T14, ref T15, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefUnmanaged(i), ref field1.RefUnmanaged(i), ref field2.RefUnmanaged(i), ref field3.RefUnmanaged(i), ref field4.RefUnmanaged(i), ref field5.RefUnmanaged(i), ref field6.RefUnmanaged(i), ref field7.RefUnmanaged(i), ref field8.RefUnmanaged(i), ref field9.RefUnmanaged(i), ref field10.RefUnmanaged(i), ref field11.RefUnmanaged(i), ref field12.RefUnmanaged(i), ref field13.RefUnmanaged(i), ref field14.RefUnmanaged(i), ref field15.RefUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, ref T14, ref T15, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSharedUnmanaged(i), ref field1.RefSharedUnmanaged(i), ref field2.RefSharedUnmanaged(i), ref field3.RefSharedUnmanaged(i), ref field4.RefSharedUnmanaged(i), ref field5.RefSharedUnmanaged(i), ref field6.RefSharedUnmanaged(i), ref field7.RefSharedUnmanaged(i), ref field8.RefSharedUnmanaged(i), ref field9.RefSharedUnmanaged(i), ref field10.RefSharedUnmanaged(i), ref field11.RefSharedUnmanaged(i), ref field12.RefSharedUnmanaged(i), ref field13.RefSharedUnmanaged(i), ref field14.RefSharedUnmanaged(i), ref field15.RefSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, ref T14, ref T15, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSparseUnmanaged(i), ref field1.RefSparseUnmanaged(i), ref field2.RefSparseUnmanaged(i), ref field3.RefSparseUnmanaged(i), ref field4.RefSparseUnmanaged(i), ref field5.RefSparseUnmanaged(i), ref field6.RefSparseUnmanaged(i), ref field7.RefSparseUnmanaged(i), ref field8.RefSparseUnmanaged(i), ref field9.RefSparseUnmanaged(i), ref field10.RefSparseUnmanaged(i), ref field11.RefSparseUnmanaged(i), ref field12.RefSparseUnmanaged(i), ref field13.RefSparseUnmanaged(i), ref field14.RefSparseUnmanaged(i), ref field15.RefSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, ref T14, ref T15, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSparseSharedUnmanaged(i), ref field1.RefSparseSharedUnmanaged(i), ref field2.RefSparseSharedUnmanaged(i), ref field3.RefSparseSharedUnmanaged(i), ref field4.RefSparseSharedUnmanaged(i), ref field5.RefSparseSharedUnmanaged(i), ref field6.RefSparseSharedUnmanaged(i), ref field7.RefSparseSharedUnmanaged(i), ref field8.RefSparseSharedUnmanaged(i), ref field9.RefSparseSharedUnmanaged(i), ref field10.RefSparseSharedUnmanaged(i), ref field11.RefSparseSharedUnmanaged(i), ref field12.RefSparseSharedUnmanaged(i), ref field13.RefSparseSharedUnmanaged(i), ref field14.RefSparseSharedUnmanaged(i), ref field15.RefSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, ref T14, ref T15, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefManaged(i), ref field1.RefManaged(i), ref field2.RefManaged(i), ref field3.RefManaged(i), ref field4.RefManaged(i), ref field5.RefManaged(i), ref field6.RefManaged(i), ref field7.RefManaged(i), ref field8.RefManaged(i), ref field9.RefManaged(i), ref field10.RefManaged(i), ref field11.RefManaged(i), ref field12.RefManaged(i), ref field13.RefManaged(i), ref field14.RefManaged(i), ref field15.RefManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, ref T14, ref T15, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSharedManaged(i), ref field1.RefSharedManaged(i), ref field2.RefSharedManaged(i), ref field3.RefSharedManaged(i), ref field4.RefSharedManaged(i), ref field5.RefSharedManaged(i), ref field6.RefSharedManaged(i), ref field7.RefSharedManaged(i), ref field8.RefSharedManaged(i), ref field9.RefSharedManaged(i), ref field10.RefSharedManaged(i), ref field11.RefSharedManaged(i), ref field12.RefSharedManaged(i), ref field13.RefSharedManaged(i), ref field14.RefSharedManaged(i), ref field15.RefSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, ref T14, ref T15, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSparseManaged(i), ref field1.RefSparseManaged(i), ref field2.RefSparseManaged(i), ref field3.RefSparseManaged(i), ref field4.RefSparseManaged(i), ref field5.RefSparseManaged(i), ref field6.RefSparseManaged(i), ref field7.RefSparseManaged(i), ref field8.RefSparseManaged(i), ref field9.RefSparseManaged(i), ref field10.RefSparseManaged(i), ref field11.RefSparseManaged(i), ref field12.RefSparseManaged(i), ref field13.RefSparseManaged(i), ref field14.RefSparseManaged(i), ref field15.RefSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, ref T14, ref T15, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSparseSharedManaged(i), ref field1.RefSparseSharedManaged(i), ref field2.RefSparseSharedManaged(i), ref field3.RefSparseSharedManaged(i), ref field4.RefSparseSharedManaged(i), ref field5.RefSparseSharedManaged(i), ref field6.RefSparseSharedManaged(i), ref field7.RefSparseSharedManaged(i), ref field8.RefSparseSharedManaged(i), ref field9.RefSparseSharedManaged(i), ref field10.RefSparseSharedManaged(i), ref field11.RefSparseSharedManaged(i), ref field12.RefSparseSharedManaged(i), ref field13.RefSparseSharedManaged(i), ref field14.RefSparseSharedManaged(i), ref field15.RefSparseSharedManaged(i));
+        }
     }
 
     /// <summary>
@@ -143,15 +613,93 @@ public static void Each<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8); byte* pointer9 = (byte*)it.GetPointer<T9>(9); byte* pointer10 = (byte*)it.GetPointer<T10>(10); byte* pointer11 = (byte*)it.GetPointer<T11>(11); byte* pointer12 = (byte*)it.GetPointer<T12>(12); byte* pointer13 = (byte*)it.GetPointer<T13>(13); byte* pointer14 = (byte*)it.GetPointer<T14>(14); byte* pointer15 = (byte*)it.GetPointer<T15>(15);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8); int step9 = it.Step<T9>(9); int step10 = it.Step<T10>(10); int step11 = it.Step<T11>(11); int step12 = it.Step<T12>(12); int step13 = it.Step<T13>(13); int step14 = it.Step<T14>(14); int step15 = it.Step<T15>(15);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8); FieldData<T9> field9 = it.GetFieldData<T9>(9); FieldData<T10> field10 = it.GetFieldData<T10>(10); FieldData<T11> field11 = it.GetFieldData<T11>(11); FieldData<T12> field12 = it.GetFieldData<T12>(12); FieldData<T13> field13 = it.GetFieldData<T13>(13); FieldData<T14> field14 = it.GetFieldData<T14>(14); FieldData<T15> field15 = it.GetFieldData<T15>(15);
+        IterationTechnique flags = it.GetIterationTechnique(16);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8], pointer9 = &pointer9[step9], pointer10 = &pointer10[step10], pointer11 = &pointer11[step11], pointer12 = &pointer12[step12], pointer13 = &pointer13[step13], pointer14 = &pointer14[step14], pointer15 = &pointer15[step15])
-            callback((T0*)pointer0, (T1*)pointer1, (T2*)pointer2, (T3*)pointer3, (T4*)pointer4, (T5*)pointer5, (T6*)pointer6, (T7*)pointer7, (T8*)pointer8, (T9*)pointer9, (T10*)pointer10, (T11*)pointer11, (T12*)pointer12, (T13*)pointer13, (T14*)pointer14, (T15*)pointer15);
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>() || RuntimeHelpers.IsReferenceOrContainsReferences<T9>() || RuntimeHelpers.IsReferenceOrContainsReferences<T10>() || RuntimeHelpers.IsReferenceOrContainsReferences<T11>() || RuntimeHelpers.IsReferenceOrContainsReferences<T12>() || RuntimeHelpers.IsReferenceOrContainsReferences<T13>() || RuntimeHelpers.IsReferenceOrContainsReferences<T14>() || RuntimeHelpers.IsReferenceOrContainsReferences<T15>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerUnmanaged(i), field1.PointerUnmanaged(i), field2.PointerUnmanaged(i), field3.PointerUnmanaged(i), field4.PointerUnmanaged(i), field5.PointerUnmanaged(i), field6.PointerUnmanaged(i), field7.PointerUnmanaged(i), field8.PointerUnmanaged(i), field9.PointerUnmanaged(i), field10.PointerUnmanaged(i), field11.PointerUnmanaged(i), field12.PointerUnmanaged(i), field13.PointerUnmanaged(i), field14.PointerUnmanaged(i), field15.PointerUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSharedUnmanaged(i), field1.PointerSharedUnmanaged(i), field2.PointerSharedUnmanaged(i), field3.PointerSharedUnmanaged(i), field4.PointerSharedUnmanaged(i), field5.PointerSharedUnmanaged(i), field6.PointerSharedUnmanaged(i), field7.PointerSharedUnmanaged(i), field8.PointerSharedUnmanaged(i), field9.PointerSharedUnmanaged(i), field10.PointerSharedUnmanaged(i), field11.PointerSharedUnmanaged(i), field12.PointerSharedUnmanaged(i), field13.PointerSharedUnmanaged(i), field14.PointerSharedUnmanaged(i), field15.PointerSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSparseUnmanaged(i), field1.PointerSparseUnmanaged(i), field2.PointerSparseUnmanaged(i), field3.PointerSparseUnmanaged(i), field4.PointerSparseUnmanaged(i), field5.PointerSparseUnmanaged(i), field6.PointerSparseUnmanaged(i), field7.PointerSparseUnmanaged(i), field8.PointerSparseUnmanaged(i), field9.PointerSparseUnmanaged(i), field10.PointerSparseUnmanaged(i), field11.PointerSparseUnmanaged(i), field12.PointerSparseUnmanaged(i), field13.PointerSparseUnmanaged(i), field14.PointerSparseUnmanaged(i), field15.PointerSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSparseSharedUnmanaged(i), field1.PointerSparseSharedUnmanaged(i), field2.PointerSparseSharedUnmanaged(i), field3.PointerSparseSharedUnmanaged(i), field4.PointerSparseSharedUnmanaged(i), field5.PointerSparseSharedUnmanaged(i), field6.PointerSparseSharedUnmanaged(i), field7.PointerSparseSharedUnmanaged(i), field8.PointerSparseSharedUnmanaged(i), field9.PointerSparseSharedUnmanaged(i), field10.PointerSparseSharedUnmanaged(i), field11.PointerSparseSharedUnmanaged(i), field12.PointerSparseSharedUnmanaged(i), field13.PointerSparseSharedUnmanaged(i), field14.PointerSparseSharedUnmanaged(i), field15.PointerSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerManaged(i), field1.PointerManaged(i), field2.PointerManaged(i), field3.PointerManaged(i), field4.PointerManaged(i), field5.PointerManaged(i), field6.PointerManaged(i), field7.PointerManaged(i), field8.PointerManaged(i), field9.PointerManaged(i), field10.PointerManaged(i), field11.PointerManaged(i), field12.PointerManaged(i), field13.PointerManaged(i), field14.PointerManaged(i), field15.PointerManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSharedManaged(i), field1.PointerSharedManaged(i), field2.PointerSharedManaged(i), field3.PointerSharedManaged(i), field4.PointerSharedManaged(i), field5.PointerSharedManaged(i), field6.PointerSharedManaged(i), field7.PointerSharedManaged(i), field8.PointerSharedManaged(i), field9.PointerSharedManaged(i), field10.PointerSharedManaged(i), field11.PointerSharedManaged(i), field12.PointerSharedManaged(i), field13.PointerSharedManaged(i), field14.PointerSharedManaged(i), field15.PointerSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSparseManaged(i), field1.PointerSparseManaged(i), field2.PointerSparseManaged(i), field3.PointerSparseManaged(i), field4.PointerSparseManaged(i), field5.PointerSparseManaged(i), field6.PointerSparseManaged(i), field7.PointerSparseManaged(i), field8.PointerSparseManaged(i), field9.PointerSparseManaged(i), field10.PointerSparseManaged(i), field11.PointerSparseManaged(i), field12.PointerSparseManaged(i), field13.PointerSparseManaged(i), field14.PointerSparseManaged(i), field15.PointerSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSparseSharedManaged(i), field1.PointerSparseSharedManaged(i), field2.PointerSparseSharedManaged(i), field3.PointerSparseSharedManaged(i), field4.PointerSparseSharedManaged(i), field5.PointerSparseSharedManaged(i), field6.PointerSparseSharedManaged(i), field7.PointerSparseSharedManaged(i), field8.PointerSparseSharedManaged(i), field9.PointerSparseSharedManaged(i), field10.PointerSparseSharedManaged(i), field11.PointerSparseSharedManaged(i), field12.PointerSparseSharedManaged(i), field13.PointerSparseSharedManaged(i), field14.PointerSparseSharedManaged(i), field15.PointerSparseSharedManaged(i));
+        }
     }
 
     /// <summary>
@@ -164,15 +712,93 @@ public static void Each<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T
     {
         int count = it.Handle->count; Ecs.Assert(it.Handle->count > 0, "No entities returned, use Iter() or Each() without the entity argument instead.");
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8); byte* pointer9 = (byte*)it.GetPointer<T9>(9); byte* pointer10 = (byte*)it.GetPointer<T10>(10); byte* pointer11 = (byte*)it.GetPointer<T11>(11); byte* pointer12 = (byte*)it.GetPointer<T12>(12); byte* pointer13 = (byte*)it.GetPointer<T13>(13); byte* pointer14 = (byte*)it.GetPointer<T14>(14); byte* pointer15 = (byte*)it.GetPointer<T15>(15);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8); int step9 = it.Step<T9>(9); int step10 = it.Step<T10>(10); int step11 = it.Step<T11>(11); int step12 = it.Step<T12>(12); int step13 = it.Step<T13>(13); int step14 = it.Step<T14>(14); int step15 = it.Step<T15>(15);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8); FieldData<T9> field9 = it.GetFieldData<T9>(9); FieldData<T10> field10 = it.GetFieldData<T10>(10); FieldData<T11> field11 = it.GetFieldData<T11>(11); FieldData<T12> field12 = it.GetFieldData<T12>(12); FieldData<T13> field13 = it.GetFieldData<T13>(13); FieldData<T14> field14 = it.GetFieldData<T14>(14); FieldData<T15> field15 = it.GetFieldData<T15>(15);
+        IterationTechnique flags = it.GetIterationTechnique(16);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8], pointer9 = &pointer9[step9], pointer10 = &pointer10[step10], pointer11 = &pointer11[step11], pointer12 = &pointer12[step12], pointer13 = &pointer13[step13], pointer14 = &pointer14[step14], pointer15 = &pointer15[step15])
-            callback(new Entity(it.Handle->world, it.Handle->entities[i]), (T0*)pointer0, (T1*)pointer1, (T2*)pointer2, (T3*)pointer3, (T4*)pointer4, (T5*)pointer5, (T6*)pointer6, (T7*)pointer7, (T8*)pointer8, (T9*)pointer9, (T10*)pointer10, (T11*)pointer11, (T12*)pointer12, (T13*)pointer13, (T14*)pointer14, (T15*)pointer15);
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>() || RuntimeHelpers.IsReferenceOrContainsReferences<T9>() || RuntimeHelpers.IsReferenceOrContainsReferences<T10>() || RuntimeHelpers.IsReferenceOrContainsReferences<T11>() || RuntimeHelpers.IsReferenceOrContainsReferences<T12>() || RuntimeHelpers.IsReferenceOrContainsReferences<T13>() || RuntimeHelpers.IsReferenceOrContainsReferences<T14>() || RuntimeHelpers.IsReferenceOrContainsReferences<T15>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerUnmanaged(i), field1.PointerUnmanaged(i), field2.PointerUnmanaged(i), field3.PointerUnmanaged(i), field4.PointerUnmanaged(i), field5.PointerUnmanaged(i), field6.PointerUnmanaged(i), field7.PointerUnmanaged(i), field8.PointerUnmanaged(i), field9.PointerUnmanaged(i), field10.PointerUnmanaged(i), field11.PointerUnmanaged(i), field12.PointerUnmanaged(i), field13.PointerUnmanaged(i), field14.PointerUnmanaged(i), field15.PointerUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSharedUnmanaged(i), field1.PointerSharedUnmanaged(i), field2.PointerSharedUnmanaged(i), field3.PointerSharedUnmanaged(i), field4.PointerSharedUnmanaged(i), field5.PointerSharedUnmanaged(i), field6.PointerSharedUnmanaged(i), field7.PointerSharedUnmanaged(i), field8.PointerSharedUnmanaged(i), field9.PointerSharedUnmanaged(i), field10.PointerSharedUnmanaged(i), field11.PointerSharedUnmanaged(i), field12.PointerSharedUnmanaged(i), field13.PointerSharedUnmanaged(i), field14.PointerSharedUnmanaged(i), field15.PointerSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseUnmanaged(i), field1.PointerSparseUnmanaged(i), field2.PointerSparseUnmanaged(i), field3.PointerSparseUnmanaged(i), field4.PointerSparseUnmanaged(i), field5.PointerSparseUnmanaged(i), field6.PointerSparseUnmanaged(i), field7.PointerSparseUnmanaged(i), field8.PointerSparseUnmanaged(i), field9.PointerSparseUnmanaged(i), field10.PointerSparseUnmanaged(i), field11.PointerSparseUnmanaged(i), field12.PointerSparseUnmanaged(i), field13.PointerSparseUnmanaged(i), field14.PointerSparseUnmanaged(i), field15.PointerSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseSharedUnmanaged(i), field1.PointerSparseSharedUnmanaged(i), field2.PointerSparseSharedUnmanaged(i), field3.PointerSparseSharedUnmanaged(i), field4.PointerSparseSharedUnmanaged(i), field5.PointerSparseSharedUnmanaged(i), field6.PointerSparseSharedUnmanaged(i), field7.PointerSparseSharedUnmanaged(i), field8.PointerSparseSharedUnmanaged(i), field9.PointerSparseSharedUnmanaged(i), field10.PointerSparseSharedUnmanaged(i), field11.PointerSparseSharedUnmanaged(i), field12.PointerSparseSharedUnmanaged(i), field13.PointerSparseSharedUnmanaged(i), field14.PointerSparseSharedUnmanaged(i), field15.PointerSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerManaged(i), field1.PointerManaged(i), field2.PointerManaged(i), field3.PointerManaged(i), field4.PointerManaged(i), field5.PointerManaged(i), field6.PointerManaged(i), field7.PointerManaged(i), field8.PointerManaged(i), field9.PointerManaged(i), field10.PointerManaged(i), field11.PointerManaged(i), field12.PointerManaged(i), field13.PointerManaged(i), field14.PointerManaged(i), field15.PointerManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSharedManaged(i), field1.PointerSharedManaged(i), field2.PointerSharedManaged(i), field3.PointerSharedManaged(i), field4.PointerSharedManaged(i), field5.PointerSharedManaged(i), field6.PointerSharedManaged(i), field7.PointerSharedManaged(i), field8.PointerSharedManaged(i), field9.PointerSharedManaged(i), field10.PointerSharedManaged(i), field11.PointerSharedManaged(i), field12.PointerSharedManaged(i), field13.PointerSharedManaged(i), field14.PointerSharedManaged(i), field15.PointerSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseManaged(i), field1.PointerSparseManaged(i), field2.PointerSparseManaged(i), field3.PointerSparseManaged(i), field4.PointerSparseManaged(i), field5.PointerSparseManaged(i), field6.PointerSparseManaged(i), field7.PointerSparseManaged(i), field8.PointerSparseManaged(i), field9.PointerSparseManaged(i), field10.PointerSparseManaged(i), field11.PointerSparseManaged(i), field12.PointerSparseManaged(i), field13.PointerSparseManaged(i), field14.PointerSparseManaged(i), field15.PointerSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseSharedManaged(i), field1.PointerSparseSharedManaged(i), field2.PointerSparseSharedManaged(i), field3.PointerSparseSharedManaged(i), field4.PointerSparseSharedManaged(i), field5.PointerSparseSharedManaged(i), field6.PointerSparseSharedManaged(i), field7.PointerSparseSharedManaged(i), field8.PointerSparseSharedManaged(i), field9.PointerSparseSharedManaged(i), field10.PointerSparseSharedManaged(i), field11.PointerSparseSharedManaged(i), field12.PointerSparseSharedManaged(i), field13.PointerSparseSharedManaged(i), field14.PointerSparseSharedManaged(i), field15.PointerSparseSharedManaged(i));
+        }
     }
 
     /// <summary>
@@ -185,15 +811,93 @@ public static void Each<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8); byte* pointer9 = (byte*)it.GetPointer<T9>(9); byte* pointer10 = (byte*)it.GetPointer<T10>(10); byte* pointer11 = (byte*)it.GetPointer<T11>(11); byte* pointer12 = (byte*)it.GetPointer<T12>(12); byte* pointer13 = (byte*)it.GetPointer<T13>(13); byte* pointer14 = (byte*)it.GetPointer<T14>(14); byte* pointer15 = (byte*)it.GetPointer<T15>(15);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8); int step9 = it.Step<T9>(9); int step10 = it.Step<T10>(10); int step11 = it.Step<T11>(11); int step12 = it.Step<T12>(12); int step13 = it.Step<T13>(13); int step14 = it.Step<T14>(14); int step15 = it.Step<T15>(15);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8); FieldData<T9> field9 = it.GetFieldData<T9>(9); FieldData<T10> field10 = it.GetFieldData<T10>(10); FieldData<T11> field11 = it.GetFieldData<T11>(11); FieldData<T12> field12 = it.GetFieldData<T12>(12); FieldData<T13> field13 = it.GetFieldData<T13>(13); FieldData<T14> field14 = it.GetFieldData<T14>(14); FieldData<T15> field15 = it.GetFieldData<T15>(15);
+        IterationTechnique flags = it.GetIterationTechnique(16);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8], pointer9 = &pointer9[step9], pointer10 = &pointer10[step10], pointer11 = &pointer11[step11], pointer12 = &pointer12[step12], pointer13 = &pointer13[step13], pointer14 = &pointer14[step14], pointer15 = &pointer15[step15])
-            callback(it, i, (T0*)pointer0, (T1*)pointer1, (T2*)pointer2, (T3*)pointer3, (T4*)pointer4, (T5*)pointer5, (T6*)pointer6, (T7*)pointer7, (T8*)pointer8, (T9*)pointer9, (T10*)pointer10, (T11*)pointer11, (T12*)pointer12, (T13*)pointer13, (T14*)pointer14, (T15*)pointer15);
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>() || RuntimeHelpers.IsReferenceOrContainsReferences<T9>() || RuntimeHelpers.IsReferenceOrContainsReferences<T10>() || RuntimeHelpers.IsReferenceOrContainsReferences<T11>() || RuntimeHelpers.IsReferenceOrContainsReferences<T12>() || RuntimeHelpers.IsReferenceOrContainsReferences<T13>() || RuntimeHelpers.IsReferenceOrContainsReferences<T14>() || RuntimeHelpers.IsReferenceOrContainsReferences<T15>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerUnmanaged(i), field1.PointerUnmanaged(i), field2.PointerUnmanaged(i), field3.PointerUnmanaged(i), field4.PointerUnmanaged(i), field5.PointerUnmanaged(i), field6.PointerUnmanaged(i), field7.PointerUnmanaged(i), field8.PointerUnmanaged(i), field9.PointerUnmanaged(i), field10.PointerUnmanaged(i), field11.PointerUnmanaged(i), field12.PointerUnmanaged(i), field13.PointerUnmanaged(i), field14.PointerUnmanaged(i), field15.PointerUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSharedUnmanaged(i), field1.PointerSharedUnmanaged(i), field2.PointerSharedUnmanaged(i), field3.PointerSharedUnmanaged(i), field4.PointerSharedUnmanaged(i), field5.PointerSharedUnmanaged(i), field6.PointerSharedUnmanaged(i), field7.PointerSharedUnmanaged(i), field8.PointerSharedUnmanaged(i), field9.PointerSharedUnmanaged(i), field10.PointerSharedUnmanaged(i), field11.PointerSharedUnmanaged(i), field12.PointerSharedUnmanaged(i), field13.PointerSharedUnmanaged(i), field14.PointerSharedUnmanaged(i), field15.PointerSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSparseUnmanaged(i), field1.PointerSparseUnmanaged(i), field2.PointerSparseUnmanaged(i), field3.PointerSparseUnmanaged(i), field4.PointerSparseUnmanaged(i), field5.PointerSparseUnmanaged(i), field6.PointerSparseUnmanaged(i), field7.PointerSparseUnmanaged(i), field8.PointerSparseUnmanaged(i), field9.PointerSparseUnmanaged(i), field10.PointerSparseUnmanaged(i), field11.PointerSparseUnmanaged(i), field12.PointerSparseUnmanaged(i), field13.PointerSparseUnmanaged(i), field14.PointerSparseUnmanaged(i), field15.PointerSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSparseSharedUnmanaged(i), field1.PointerSparseSharedUnmanaged(i), field2.PointerSparseSharedUnmanaged(i), field3.PointerSparseSharedUnmanaged(i), field4.PointerSparseSharedUnmanaged(i), field5.PointerSparseSharedUnmanaged(i), field6.PointerSparseSharedUnmanaged(i), field7.PointerSparseSharedUnmanaged(i), field8.PointerSparseSharedUnmanaged(i), field9.PointerSparseSharedUnmanaged(i), field10.PointerSparseSharedUnmanaged(i), field11.PointerSparseSharedUnmanaged(i), field12.PointerSparseSharedUnmanaged(i), field13.PointerSparseSharedUnmanaged(i), field14.PointerSparseSharedUnmanaged(i), field15.PointerSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerManaged(i), field1.PointerManaged(i), field2.PointerManaged(i), field3.PointerManaged(i), field4.PointerManaged(i), field5.PointerManaged(i), field6.PointerManaged(i), field7.PointerManaged(i), field8.PointerManaged(i), field9.PointerManaged(i), field10.PointerManaged(i), field11.PointerManaged(i), field12.PointerManaged(i), field13.PointerManaged(i), field14.PointerManaged(i), field15.PointerManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSharedManaged(i), field1.PointerSharedManaged(i), field2.PointerSharedManaged(i), field3.PointerSharedManaged(i), field4.PointerSharedManaged(i), field5.PointerSharedManaged(i), field6.PointerSharedManaged(i), field7.PointerSharedManaged(i), field8.PointerSharedManaged(i), field9.PointerSharedManaged(i), field10.PointerSharedManaged(i), field11.PointerSharedManaged(i), field12.PointerSharedManaged(i), field13.PointerSharedManaged(i), field14.PointerSharedManaged(i), field15.PointerSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSparseManaged(i), field1.PointerSparseManaged(i), field2.PointerSparseManaged(i), field3.PointerSparseManaged(i), field4.PointerSparseManaged(i), field5.PointerSparseManaged(i), field6.PointerSparseManaged(i), field7.PointerSparseManaged(i), field8.PointerSparseManaged(i), field9.PointerSparseManaged(i), field10.PointerSparseManaged(i), field11.PointerSparseManaged(i), field12.PointerSparseManaged(i), field13.PointerSparseManaged(i), field14.PointerSparseManaged(i), field15.PointerSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSparseSharedManaged(i), field1.PointerSparseSharedManaged(i), field2.PointerSparseSharedManaged(i), field3.PointerSparseSharedManaged(i), field4.PointerSparseSharedManaged(i), field5.PointerSparseSharedManaged(i), field6.PointerSparseSharedManaged(i), field7.PointerSparseSharedManaged(i), field8.PointerSparseSharedManaged(i), field9.PointerSparseSharedManaged(i), field10.PointerSparseSharedManaged(i), field11.PointerSparseSharedManaged(i), field12.PointerSparseSharedManaged(i), field13.PointerSparseSharedManaged(i), field14.PointerSparseSharedManaged(i), field15.PointerSparseSharedManaged(i));
+        }
     }
 
     /// <summary>
@@ -206,15 +910,93 @@ public static void Each<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8); byte* pointer9 = (byte*)it.GetPointer<T9>(9); byte* pointer10 = (byte*)it.GetPointer<T10>(10); byte* pointer11 = (byte*)it.GetPointer<T11>(11); byte* pointer12 = (byte*)it.GetPointer<T12>(12); byte* pointer13 = (byte*)it.GetPointer<T13>(13); byte* pointer14 = (byte*)it.GetPointer<T14>(14); byte* pointer15 = (byte*)it.GetPointer<T15>(15);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8); int step9 = it.Step<T9>(9); int step10 = it.Step<T10>(10); int step11 = it.Step<T11>(11); int step12 = it.Step<T12>(12); int step13 = it.Step<T13>(13); int step14 = it.Step<T14>(14); int step15 = it.Step<T15>(15);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8); FieldData<T9> field9 = it.GetFieldData<T9>(9); FieldData<T10> field10 = it.GetFieldData<T10>(10); FieldData<T11> field11 = it.GetFieldData<T11>(11); FieldData<T12> field12 = it.GetFieldData<T12>(12); FieldData<T13> field13 = it.GetFieldData<T13>(13); FieldData<T14> field14 = it.GetFieldData<T14>(14); FieldData<T15> field15 = it.GetFieldData<T15>(15);
+        IterationTechnique flags = it.GetIterationTechnique(16);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8], pointer9 = &pointer9[step9], pointer10 = &pointer10[step10], pointer11 = &pointer11[step11], pointer12 = &pointer12[step12], pointer13 = &pointer13[step13], pointer14 = &pointer14[step14], pointer15 = &pointer15[step15])
-            callback((T0*)pointer0, (T1*)pointer1, (T2*)pointer2, (T3*)pointer3, (T4*)pointer4, (T5*)pointer5, (T6*)pointer6, (T7*)pointer7, (T8*)pointer8, (T9*)pointer9, (T10*)pointer10, (T11*)pointer11, (T12*)pointer12, (T13*)pointer13, (T14*)pointer14, (T15*)pointer15);
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>() || RuntimeHelpers.IsReferenceOrContainsReferences<T9>() || RuntimeHelpers.IsReferenceOrContainsReferences<T10>() || RuntimeHelpers.IsReferenceOrContainsReferences<T11>() || RuntimeHelpers.IsReferenceOrContainsReferences<T12>() || RuntimeHelpers.IsReferenceOrContainsReferences<T13>() || RuntimeHelpers.IsReferenceOrContainsReferences<T14>() || RuntimeHelpers.IsReferenceOrContainsReferences<T15>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, T14*, T15*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerUnmanaged(i), field1.PointerUnmanaged(i), field2.PointerUnmanaged(i), field3.PointerUnmanaged(i), field4.PointerUnmanaged(i), field5.PointerUnmanaged(i), field6.PointerUnmanaged(i), field7.PointerUnmanaged(i), field8.PointerUnmanaged(i), field9.PointerUnmanaged(i), field10.PointerUnmanaged(i), field11.PointerUnmanaged(i), field12.PointerUnmanaged(i), field13.PointerUnmanaged(i), field14.PointerUnmanaged(i), field15.PointerUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, T14*, T15*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSharedUnmanaged(i), field1.PointerSharedUnmanaged(i), field2.PointerSharedUnmanaged(i), field3.PointerSharedUnmanaged(i), field4.PointerSharedUnmanaged(i), field5.PointerSharedUnmanaged(i), field6.PointerSharedUnmanaged(i), field7.PointerSharedUnmanaged(i), field8.PointerSharedUnmanaged(i), field9.PointerSharedUnmanaged(i), field10.PointerSharedUnmanaged(i), field11.PointerSharedUnmanaged(i), field12.PointerSharedUnmanaged(i), field13.PointerSharedUnmanaged(i), field14.PointerSharedUnmanaged(i), field15.PointerSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, T14*, T15*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSparseUnmanaged(i), field1.PointerSparseUnmanaged(i), field2.PointerSparseUnmanaged(i), field3.PointerSparseUnmanaged(i), field4.PointerSparseUnmanaged(i), field5.PointerSparseUnmanaged(i), field6.PointerSparseUnmanaged(i), field7.PointerSparseUnmanaged(i), field8.PointerSparseUnmanaged(i), field9.PointerSparseUnmanaged(i), field10.PointerSparseUnmanaged(i), field11.PointerSparseUnmanaged(i), field12.PointerSparseUnmanaged(i), field13.PointerSparseUnmanaged(i), field14.PointerSparseUnmanaged(i), field15.PointerSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, T14*, T15*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSparseSharedUnmanaged(i), field1.PointerSparseSharedUnmanaged(i), field2.PointerSparseSharedUnmanaged(i), field3.PointerSparseSharedUnmanaged(i), field4.PointerSparseSharedUnmanaged(i), field5.PointerSparseSharedUnmanaged(i), field6.PointerSparseSharedUnmanaged(i), field7.PointerSparseSharedUnmanaged(i), field8.PointerSparseSharedUnmanaged(i), field9.PointerSparseSharedUnmanaged(i), field10.PointerSparseSharedUnmanaged(i), field11.PointerSparseSharedUnmanaged(i), field12.PointerSparseSharedUnmanaged(i), field13.PointerSparseSharedUnmanaged(i), field14.PointerSparseSharedUnmanaged(i), field15.PointerSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, T14*, T15*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerManaged(i), field1.PointerManaged(i), field2.PointerManaged(i), field3.PointerManaged(i), field4.PointerManaged(i), field5.PointerManaged(i), field6.PointerManaged(i), field7.PointerManaged(i), field8.PointerManaged(i), field9.PointerManaged(i), field10.PointerManaged(i), field11.PointerManaged(i), field12.PointerManaged(i), field13.PointerManaged(i), field14.PointerManaged(i), field15.PointerManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, T14*, T15*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSharedManaged(i), field1.PointerSharedManaged(i), field2.PointerSharedManaged(i), field3.PointerSharedManaged(i), field4.PointerSharedManaged(i), field5.PointerSharedManaged(i), field6.PointerSharedManaged(i), field7.PointerSharedManaged(i), field8.PointerSharedManaged(i), field9.PointerSharedManaged(i), field10.PointerSharedManaged(i), field11.PointerSharedManaged(i), field12.PointerSharedManaged(i), field13.PointerSharedManaged(i), field14.PointerSharedManaged(i), field15.PointerSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, T14*, T15*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSparseManaged(i), field1.PointerSparseManaged(i), field2.PointerSparseManaged(i), field3.PointerSparseManaged(i), field4.PointerSparseManaged(i), field5.PointerSparseManaged(i), field6.PointerSparseManaged(i), field7.PointerSparseManaged(i), field8.PointerSparseManaged(i), field9.PointerSparseManaged(i), field10.PointerSparseManaged(i), field11.PointerSparseManaged(i), field12.PointerSparseManaged(i), field13.PointerSparseManaged(i), field14.PointerSparseManaged(i), field15.PointerSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, T14*, T15*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSparseSharedManaged(i), field1.PointerSparseSharedManaged(i), field2.PointerSparseSharedManaged(i), field3.PointerSparseSharedManaged(i), field4.PointerSparseSharedManaged(i), field5.PointerSparseSharedManaged(i), field6.PointerSparseSharedManaged(i), field7.PointerSparseSharedManaged(i), field8.PointerSparseSharedManaged(i), field9.PointerSparseSharedManaged(i), field10.PointerSparseSharedManaged(i), field11.PointerSparseSharedManaged(i), field12.PointerSparseSharedManaged(i), field13.PointerSparseSharedManaged(i), field14.PointerSparseSharedManaged(i), field15.PointerSparseSharedManaged(i));
+        }
     }
 
     /// <summary>
@@ -227,15 +1009,93 @@ public static void Each<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T
     {
         int count = it.Handle->count; Ecs.Assert(it.Handle->count > 0, "No entities returned, use Iter() or Each() without the entity argument instead.");
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8); byte* pointer9 = (byte*)it.GetPointer<T9>(9); byte* pointer10 = (byte*)it.GetPointer<T10>(10); byte* pointer11 = (byte*)it.GetPointer<T11>(11); byte* pointer12 = (byte*)it.GetPointer<T12>(12); byte* pointer13 = (byte*)it.GetPointer<T13>(13); byte* pointer14 = (byte*)it.GetPointer<T14>(14); byte* pointer15 = (byte*)it.GetPointer<T15>(15);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8); int step9 = it.Step<T9>(9); int step10 = it.Step<T10>(10); int step11 = it.Step<T11>(11); int step12 = it.Step<T12>(12); int step13 = it.Step<T13>(13); int step14 = it.Step<T14>(14); int step15 = it.Step<T15>(15);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8); FieldData<T9> field9 = it.GetFieldData<T9>(9); FieldData<T10> field10 = it.GetFieldData<T10>(10); FieldData<T11> field11 = it.GetFieldData<T11>(11); FieldData<T12> field12 = it.GetFieldData<T12>(12); FieldData<T13> field13 = it.GetFieldData<T13>(13); FieldData<T14> field14 = it.GetFieldData<T14>(14); FieldData<T15> field15 = it.GetFieldData<T15>(15);
+        IterationTechnique flags = it.GetIterationTechnique(16);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8], pointer9 = &pointer9[step9], pointer10 = &pointer10[step10], pointer11 = &pointer11[step11], pointer12 = &pointer12[step12], pointer13 = &pointer13[step13], pointer14 = &pointer14[step14], pointer15 = &pointer15[step15])
-            callback(new Entity(it.Handle->world, it.Handle->entities[i]), (T0*)pointer0, (T1*)pointer1, (T2*)pointer2, (T3*)pointer3, (T4*)pointer4, (T5*)pointer5, (T6*)pointer6, (T7*)pointer7, (T8*)pointer8, (T9*)pointer9, (T10*)pointer10, (T11*)pointer11, (T12*)pointer12, (T13*)pointer13, (T14*)pointer14, (T15*)pointer15);
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>() || RuntimeHelpers.IsReferenceOrContainsReferences<T9>() || RuntimeHelpers.IsReferenceOrContainsReferences<T10>() || RuntimeHelpers.IsReferenceOrContainsReferences<T11>() || RuntimeHelpers.IsReferenceOrContainsReferences<T12>() || RuntimeHelpers.IsReferenceOrContainsReferences<T13>() || RuntimeHelpers.IsReferenceOrContainsReferences<T14>() || RuntimeHelpers.IsReferenceOrContainsReferences<T15>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, T14*, T15*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerUnmanaged(i), field1.PointerUnmanaged(i), field2.PointerUnmanaged(i), field3.PointerUnmanaged(i), field4.PointerUnmanaged(i), field5.PointerUnmanaged(i), field6.PointerUnmanaged(i), field7.PointerUnmanaged(i), field8.PointerUnmanaged(i), field9.PointerUnmanaged(i), field10.PointerUnmanaged(i), field11.PointerUnmanaged(i), field12.PointerUnmanaged(i), field13.PointerUnmanaged(i), field14.PointerUnmanaged(i), field15.PointerUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, T14*, T15*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSharedUnmanaged(i), field1.PointerSharedUnmanaged(i), field2.PointerSharedUnmanaged(i), field3.PointerSharedUnmanaged(i), field4.PointerSharedUnmanaged(i), field5.PointerSharedUnmanaged(i), field6.PointerSharedUnmanaged(i), field7.PointerSharedUnmanaged(i), field8.PointerSharedUnmanaged(i), field9.PointerSharedUnmanaged(i), field10.PointerSharedUnmanaged(i), field11.PointerSharedUnmanaged(i), field12.PointerSharedUnmanaged(i), field13.PointerSharedUnmanaged(i), field14.PointerSharedUnmanaged(i), field15.PointerSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, T14*, T15*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseUnmanaged(i), field1.PointerSparseUnmanaged(i), field2.PointerSparseUnmanaged(i), field3.PointerSparseUnmanaged(i), field4.PointerSparseUnmanaged(i), field5.PointerSparseUnmanaged(i), field6.PointerSparseUnmanaged(i), field7.PointerSparseUnmanaged(i), field8.PointerSparseUnmanaged(i), field9.PointerSparseUnmanaged(i), field10.PointerSparseUnmanaged(i), field11.PointerSparseUnmanaged(i), field12.PointerSparseUnmanaged(i), field13.PointerSparseUnmanaged(i), field14.PointerSparseUnmanaged(i), field15.PointerSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, T14*, T15*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseSharedUnmanaged(i), field1.PointerSparseSharedUnmanaged(i), field2.PointerSparseSharedUnmanaged(i), field3.PointerSparseSharedUnmanaged(i), field4.PointerSparseSharedUnmanaged(i), field5.PointerSparseSharedUnmanaged(i), field6.PointerSparseSharedUnmanaged(i), field7.PointerSparseSharedUnmanaged(i), field8.PointerSparseSharedUnmanaged(i), field9.PointerSparseSharedUnmanaged(i), field10.PointerSparseSharedUnmanaged(i), field11.PointerSparseSharedUnmanaged(i), field12.PointerSparseSharedUnmanaged(i), field13.PointerSparseSharedUnmanaged(i), field14.PointerSparseSharedUnmanaged(i), field15.PointerSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, T14*, T15*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerManaged(i), field1.PointerManaged(i), field2.PointerManaged(i), field3.PointerManaged(i), field4.PointerManaged(i), field5.PointerManaged(i), field6.PointerManaged(i), field7.PointerManaged(i), field8.PointerManaged(i), field9.PointerManaged(i), field10.PointerManaged(i), field11.PointerManaged(i), field12.PointerManaged(i), field13.PointerManaged(i), field14.PointerManaged(i), field15.PointerManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, T14*, T15*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSharedManaged(i), field1.PointerSharedManaged(i), field2.PointerSharedManaged(i), field3.PointerSharedManaged(i), field4.PointerSharedManaged(i), field5.PointerSharedManaged(i), field6.PointerSharedManaged(i), field7.PointerSharedManaged(i), field8.PointerSharedManaged(i), field9.PointerSharedManaged(i), field10.PointerSharedManaged(i), field11.PointerSharedManaged(i), field12.PointerSharedManaged(i), field13.PointerSharedManaged(i), field14.PointerSharedManaged(i), field15.PointerSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, T14*, T15*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseManaged(i), field1.PointerSparseManaged(i), field2.PointerSparseManaged(i), field3.PointerSparseManaged(i), field4.PointerSparseManaged(i), field5.PointerSparseManaged(i), field6.PointerSparseManaged(i), field7.PointerSparseManaged(i), field8.PointerSparseManaged(i), field9.PointerSparseManaged(i), field10.PointerSparseManaged(i), field11.PointerSparseManaged(i), field12.PointerSparseManaged(i), field13.PointerSparseManaged(i), field14.PointerSparseManaged(i), field15.PointerSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, T14*, T15*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseSharedManaged(i), field1.PointerSparseSharedManaged(i), field2.PointerSparseSharedManaged(i), field3.PointerSparseSharedManaged(i), field4.PointerSparseSharedManaged(i), field5.PointerSparseSharedManaged(i), field6.PointerSparseSharedManaged(i), field7.PointerSparseSharedManaged(i), field8.PointerSparseSharedManaged(i), field9.PointerSparseSharedManaged(i), field10.PointerSparseSharedManaged(i), field11.PointerSparseSharedManaged(i), field12.PointerSparseSharedManaged(i), field13.PointerSparseSharedManaged(i), field14.PointerSparseSharedManaged(i), field15.PointerSparseSharedManaged(i));
+        }
     }
 
     /// <summary>
@@ -248,14 +1108,92 @@ public static void Each<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8); byte* pointer9 = (byte*)it.GetPointer<T9>(9); byte* pointer10 = (byte*)it.GetPointer<T10>(10); byte* pointer11 = (byte*)it.GetPointer<T11>(11); byte* pointer12 = (byte*)it.GetPointer<T12>(12); byte* pointer13 = (byte*)it.GetPointer<T13>(13); byte* pointer14 = (byte*)it.GetPointer<T14>(14); byte* pointer15 = (byte*)it.GetPointer<T15>(15);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8); int step9 = it.Step<T9>(9); int step10 = it.Step<T10>(10); int step11 = it.Step<T11>(11); int step12 = it.Step<T12>(12); int step13 = it.Step<T13>(13); int step14 = it.Step<T14>(14); int step15 = it.Step<T15>(15);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8); FieldData<T9> field9 = it.GetFieldData<T9>(9); FieldData<T10> field10 = it.GetFieldData<T10>(10); FieldData<T11> field11 = it.GetFieldData<T11>(11); FieldData<T12> field12 = it.GetFieldData<T12>(12); FieldData<T13> field13 = it.GetFieldData<T13>(13); FieldData<T14> field14 = it.GetFieldData<T14>(14); FieldData<T15> field15 = it.GetFieldData<T15>(15);
+        IterationTechnique flags = it.GetIterationTechnique(16);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8], pointer9 = &pointer9[step9], pointer10 = &pointer10[step10], pointer11 = &pointer11[step11], pointer12 = &pointer12[step12], pointer13 = &pointer13[step13], pointer14 = &pointer14[step14], pointer15 = &pointer15[step15])
-            callback(it, i, (T0*)pointer0, (T1*)pointer1, (T2*)pointer2, (T3*)pointer3, (T4*)pointer4, (T5*)pointer5, (T6*)pointer6, (T7*)pointer7, (T8*)pointer8, (T9*)pointer9, (T10*)pointer10, (T11*)pointer11, (T12*)pointer12, (T13*)pointer13, (T14*)pointer14, (T15*)pointer15);
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>() || RuntimeHelpers.IsReferenceOrContainsReferences<T9>() || RuntimeHelpers.IsReferenceOrContainsReferences<T10>() || RuntimeHelpers.IsReferenceOrContainsReferences<T11>() || RuntimeHelpers.IsReferenceOrContainsReferences<T12>() || RuntimeHelpers.IsReferenceOrContainsReferences<T13>() || RuntimeHelpers.IsReferenceOrContainsReferences<T14>() || RuntimeHelpers.IsReferenceOrContainsReferences<T15>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, T14*, T15*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerUnmanaged(i), field1.PointerUnmanaged(i), field2.PointerUnmanaged(i), field3.PointerUnmanaged(i), field4.PointerUnmanaged(i), field5.PointerUnmanaged(i), field6.PointerUnmanaged(i), field7.PointerUnmanaged(i), field8.PointerUnmanaged(i), field9.PointerUnmanaged(i), field10.PointerUnmanaged(i), field11.PointerUnmanaged(i), field12.PointerUnmanaged(i), field13.PointerUnmanaged(i), field14.PointerUnmanaged(i), field15.PointerUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, T14*, T15*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSharedUnmanaged(i), field1.PointerSharedUnmanaged(i), field2.PointerSharedUnmanaged(i), field3.PointerSharedUnmanaged(i), field4.PointerSharedUnmanaged(i), field5.PointerSharedUnmanaged(i), field6.PointerSharedUnmanaged(i), field7.PointerSharedUnmanaged(i), field8.PointerSharedUnmanaged(i), field9.PointerSharedUnmanaged(i), field10.PointerSharedUnmanaged(i), field11.PointerSharedUnmanaged(i), field12.PointerSharedUnmanaged(i), field13.PointerSharedUnmanaged(i), field14.PointerSharedUnmanaged(i), field15.PointerSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, T14*, T15*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSparseUnmanaged(i), field1.PointerSparseUnmanaged(i), field2.PointerSparseUnmanaged(i), field3.PointerSparseUnmanaged(i), field4.PointerSparseUnmanaged(i), field5.PointerSparseUnmanaged(i), field6.PointerSparseUnmanaged(i), field7.PointerSparseUnmanaged(i), field8.PointerSparseUnmanaged(i), field9.PointerSparseUnmanaged(i), field10.PointerSparseUnmanaged(i), field11.PointerSparseUnmanaged(i), field12.PointerSparseUnmanaged(i), field13.PointerSparseUnmanaged(i), field14.PointerSparseUnmanaged(i), field15.PointerSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, T14*, T15*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSparseSharedUnmanaged(i), field1.PointerSparseSharedUnmanaged(i), field2.PointerSparseSharedUnmanaged(i), field3.PointerSparseSharedUnmanaged(i), field4.PointerSparseSharedUnmanaged(i), field5.PointerSparseSharedUnmanaged(i), field6.PointerSparseSharedUnmanaged(i), field7.PointerSparseSharedUnmanaged(i), field8.PointerSparseSharedUnmanaged(i), field9.PointerSparseSharedUnmanaged(i), field10.PointerSparseSharedUnmanaged(i), field11.PointerSparseSharedUnmanaged(i), field12.PointerSparseSharedUnmanaged(i), field13.PointerSparseSharedUnmanaged(i), field14.PointerSparseSharedUnmanaged(i), field15.PointerSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, T14*, T15*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerManaged(i), field1.PointerManaged(i), field2.PointerManaged(i), field3.PointerManaged(i), field4.PointerManaged(i), field5.PointerManaged(i), field6.PointerManaged(i), field7.PointerManaged(i), field8.PointerManaged(i), field9.PointerManaged(i), field10.PointerManaged(i), field11.PointerManaged(i), field12.PointerManaged(i), field13.PointerManaged(i), field14.PointerManaged(i), field15.PointerManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, T14*, T15*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSharedManaged(i), field1.PointerSharedManaged(i), field2.PointerSharedManaged(i), field3.PointerSharedManaged(i), field4.PointerSharedManaged(i), field5.PointerSharedManaged(i), field6.PointerSharedManaged(i), field7.PointerSharedManaged(i), field8.PointerSharedManaged(i), field9.PointerSharedManaged(i), field10.PointerSharedManaged(i), field11.PointerSharedManaged(i), field12.PointerSharedManaged(i), field13.PointerSharedManaged(i), field14.PointerSharedManaged(i), field15.PointerSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, T14*, T15*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSparseManaged(i), field1.PointerSparseManaged(i), field2.PointerSparseManaged(i), field3.PointerSparseManaged(i), field4.PointerSparseManaged(i), field5.PointerSparseManaged(i), field6.PointerSparseManaged(i), field7.PointerSparseManaged(i), field8.PointerSparseManaged(i), field9.PointerSparseManaged(i), field10.PointerSparseManaged(i), field11.PointerSparseManaged(i), field12.PointerSparseManaged(i), field13.PointerSparseManaged(i), field14.PointerSparseManaged(i), field15.PointerSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, T14*, T15*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSparseSharedManaged(i), field1.PointerSparseSharedManaged(i), field2.PointerSparseSharedManaged(i), field3.PointerSparseSharedManaged(i), field4.PointerSparseSharedManaged(i), field5.PointerSparseSharedManaged(i), field6.PointerSparseSharedManaged(i), field7.PointerSparseSharedManaged(i), field8.PointerSparseSharedManaged(i), field9.PointerSparseSharedManaged(i), field10.PointerSparseSharedManaged(i), field11.PointerSparseSharedManaged(i), field12.PointerSparseSharedManaged(i), field13.PointerSparseSharedManaged(i), field14.PointerSparseSharedManaged(i), field15.PointerSparseSharedManaged(i));
+        }
     }
 }
\ No newline at end of file
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/Invoker/Each/Iterator/T2.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/Invoker/Each/Iterator/T2.g.cs
index 78488736..b8bd95f1 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/Invoker/Each/Iterator/T2.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/Invoker/Each/Iterator/T2.g.cs
@@ -1,5 +1,7 @@
 // Each/Iterator/T2.g.cs
 // File was auto-generated by /_/src/Flecs.NET.Codegen/Generators/Invoker.cs
+using System;
+using System.Runtime.CompilerServices;
 using Flecs.NET.Utilities;
 using static Flecs.NET.Bindings.flecs;
 
@@ -17,15 +19,93 @@ public static void Each<T0, T1>(Iter it, Ecs.EachRefCallback<T0, T1> callback)
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1);
+        IterationTechnique flags = it.GetIterationTechnique(2);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1])
-            callback(ref Managed.GetTypeRef<T0>(pointer0), ref Managed.GetTypeRef<T1>(pointer1));
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0, ref field1);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0, ref field1);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0, ref field1);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0, ref field1);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0, ref field1);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0, ref field1);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0, ref field1);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0, ref field1);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, Ecs.EachRefCallback<T0, T1> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefUnmanaged(i), ref field1.RefUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, Ecs.EachRefCallback<T0, T1> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSharedUnmanaged(i), ref field1.RefSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, Ecs.EachRefCallback<T0, T1> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSparseUnmanaged(i), ref field1.RefSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, Ecs.EachRefCallback<T0, T1> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSparseSharedUnmanaged(i), ref field1.RefSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, Ecs.EachRefCallback<T0, T1> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefManaged(i), ref field1.RefManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, Ecs.EachRefCallback<T0, T1> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSharedManaged(i), ref field1.RefSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, Ecs.EachRefCallback<T0, T1> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSparseManaged(i), ref field1.RefSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, Ecs.EachRefCallback<T0, T1> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSparseSharedManaged(i), ref field1.RefSparseSharedManaged(i));
+        }
     }
 
     /// <summary>
@@ -38,15 +118,93 @@ public static void Each<T0, T1>(Iter it, Ecs.EachEntityRefCallback<T0, T1> callb
     {
         int count = it.Handle->count; Ecs.Assert(it.Handle->count > 0, "No entities returned, use Iter() or Each() without the entity argument instead.");
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1);
+        IterationTechnique flags = it.GetIterationTechnique(2);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1])
-            callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref Managed.GetTypeRef<T0>(pointer0), ref Managed.GetTypeRef<T1>(pointer1));
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0, ref field1);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0, ref field1);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0, ref field1);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0, ref field1);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0, ref field1);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0, ref field1);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0, ref field1);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0, ref field1);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, Ecs.EachEntityRefCallback<T0, T1> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefUnmanaged(i), ref field1.RefUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, Ecs.EachEntityRefCallback<T0, T1> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSharedUnmanaged(i), ref field1.RefSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, Ecs.EachEntityRefCallback<T0, T1> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseUnmanaged(i), ref field1.RefSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, Ecs.EachEntityRefCallback<T0, T1> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseSharedUnmanaged(i), ref field1.RefSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, Ecs.EachEntityRefCallback<T0, T1> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefManaged(i), ref field1.RefManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, Ecs.EachEntityRefCallback<T0, T1> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSharedManaged(i), ref field1.RefSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, Ecs.EachEntityRefCallback<T0, T1> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseManaged(i), ref field1.RefSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, Ecs.EachEntityRefCallback<T0, T1> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseSharedManaged(i), ref field1.RefSparseSharedManaged(i));
+        }
     }
 
     /// <summary>
@@ -59,15 +217,93 @@ public static void Each<T0, T1>(Iter it, Ecs.EachIterRefCallback<T0, T1> callbac
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1);
+        IterationTechnique flags = it.GetIterationTechnique(2);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1])
-            callback(it, i, ref Managed.GetTypeRef<T0>(pointer0), ref Managed.GetTypeRef<T1>(pointer1));
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0, ref field1);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0, ref field1);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0, ref field1);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0, ref field1);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0, ref field1);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0, ref field1);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0, ref field1);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0, ref field1);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, Ecs.EachIterRefCallback<T0, T1> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefUnmanaged(i), ref field1.RefUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, Ecs.EachIterRefCallback<T0, T1> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSharedUnmanaged(i), ref field1.RefSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, Ecs.EachIterRefCallback<T0, T1> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSparseUnmanaged(i), ref field1.RefSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, Ecs.EachIterRefCallback<T0, T1> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSparseSharedUnmanaged(i), ref field1.RefSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, Ecs.EachIterRefCallback<T0, T1> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefManaged(i), ref field1.RefManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, Ecs.EachIterRefCallback<T0, T1> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSharedManaged(i), ref field1.RefSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, Ecs.EachIterRefCallback<T0, T1> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSparseManaged(i), ref field1.RefSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, Ecs.EachIterRefCallback<T0, T1> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSparseSharedManaged(i), ref field1.RefSparseSharedManaged(i));
+        }
     }
 
     /// <summary>
@@ -80,15 +316,93 @@ public static void Each<T0, T1>(Iter it, delegate*<ref T0, ref T1, void> callbac
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1);
+        IterationTechnique flags = it.GetIterationTechnique(2);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1])
-            callback(ref Managed.GetTypeRef<T0>(pointer0), ref Managed.GetTypeRef<T1>(pointer1));
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0, ref field1);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0, ref field1);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0, ref field1);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0, ref field1);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0, ref field1);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0, ref field1);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0, ref field1);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0, ref field1);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, delegate*<ref T0, ref T1, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefUnmanaged(i), ref field1.RefUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, delegate*<ref T0, ref T1, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSharedUnmanaged(i), ref field1.RefSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, delegate*<ref T0, ref T1, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSparseUnmanaged(i), ref field1.RefSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, delegate*<ref T0, ref T1, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSparseSharedUnmanaged(i), ref field1.RefSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, delegate*<ref T0, ref T1, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefManaged(i), ref field1.RefManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, delegate*<ref T0, ref T1, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSharedManaged(i), ref field1.RefSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, delegate*<ref T0, ref T1, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSparseManaged(i), ref field1.RefSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, delegate*<ref T0, ref T1, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSparseSharedManaged(i), ref field1.RefSparseSharedManaged(i));
+        }
     }
 
     /// <summary>
@@ -101,15 +415,93 @@ public static void Each<T0, T1>(Iter it, delegate*<Entity, ref T0, ref T1, void>
     {
         int count = it.Handle->count; Ecs.Assert(it.Handle->count > 0, "No entities returned, use Iter() or Each() without the entity argument instead.");
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1);
+        IterationTechnique flags = it.GetIterationTechnique(2);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1])
-            callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref Managed.GetTypeRef<T0>(pointer0), ref Managed.GetTypeRef<T1>(pointer1));
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0, ref field1);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0, ref field1);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0, ref field1);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0, ref field1);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0, ref field1);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0, ref field1);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0, ref field1);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0, ref field1);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefUnmanaged(i), ref field1.RefUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSharedUnmanaged(i), ref field1.RefSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseUnmanaged(i), ref field1.RefSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseSharedUnmanaged(i), ref field1.RefSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, delegate*<Entity, ref T0, ref T1, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefManaged(i), ref field1.RefManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSharedManaged(i), ref field1.RefSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseManaged(i), ref field1.RefSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseSharedManaged(i), ref field1.RefSparseSharedManaged(i));
+        }
     }
 
     /// <summary>
@@ -122,15 +514,93 @@ public static void Each<T0, T1>(Iter it, delegate*<Iter, int, ref T0, ref T1, vo
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1);
+        IterationTechnique flags = it.GetIterationTechnique(2);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1])
-            callback(it, i, ref Managed.GetTypeRef<T0>(pointer0), ref Managed.GetTypeRef<T1>(pointer1));
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0, ref field1);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0, ref field1);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0, ref field1);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0, ref field1);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0, ref field1);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0, ref field1);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0, ref field1);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0, ref field1);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefUnmanaged(i), ref field1.RefUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSharedUnmanaged(i), ref field1.RefSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSparseUnmanaged(i), ref field1.RefSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSparseSharedUnmanaged(i), ref field1.RefSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefManaged(i), ref field1.RefManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSharedManaged(i), ref field1.RefSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSparseManaged(i), ref field1.RefSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSparseSharedManaged(i), ref field1.RefSparseSharedManaged(i));
+        }
     }
 
     /// <summary>
@@ -143,15 +613,93 @@ public static void Each<T0, T1>(Iter it, Ecs.EachPointerCallback<T0, T1> callbac
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1);
+        IterationTechnique flags = it.GetIterationTechnique(2);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1])
-            callback((T0*)pointer0, (T1*)pointer1);
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0, ref field1);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0, ref field1);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0, ref field1);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0, ref field1);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0, ref field1);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0, ref field1);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0, ref field1);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0, ref field1);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, Ecs.EachPointerCallback<T0, T1> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerUnmanaged(i), field1.PointerUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, Ecs.EachPointerCallback<T0, T1> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSharedUnmanaged(i), field1.PointerSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, Ecs.EachPointerCallback<T0, T1> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSparseUnmanaged(i), field1.PointerSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, Ecs.EachPointerCallback<T0, T1> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSparseSharedUnmanaged(i), field1.PointerSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, Ecs.EachPointerCallback<T0, T1> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerManaged(i), field1.PointerManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, Ecs.EachPointerCallback<T0, T1> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSharedManaged(i), field1.PointerSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, Ecs.EachPointerCallback<T0, T1> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSparseManaged(i), field1.PointerSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, Ecs.EachPointerCallback<T0, T1> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSparseSharedManaged(i), field1.PointerSparseSharedManaged(i));
+        }
     }
 
     /// <summary>
@@ -164,15 +712,93 @@ public static void Each<T0, T1>(Iter it, Ecs.EachEntityPointerCallback<T0, T1> c
     {
         int count = it.Handle->count; Ecs.Assert(it.Handle->count > 0, "No entities returned, use Iter() or Each() without the entity argument instead.");
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1);
+        IterationTechnique flags = it.GetIterationTechnique(2);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1])
-            callback(new Entity(it.Handle->world, it.Handle->entities[i]), (T0*)pointer0, (T1*)pointer1);
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0, ref field1);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0, ref field1);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0, ref field1);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0, ref field1);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0, ref field1);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0, ref field1);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0, ref field1);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0, ref field1);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, Ecs.EachEntityPointerCallback<T0, T1> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerUnmanaged(i), field1.PointerUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, Ecs.EachEntityPointerCallback<T0, T1> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSharedUnmanaged(i), field1.PointerSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, Ecs.EachEntityPointerCallback<T0, T1> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseUnmanaged(i), field1.PointerSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, Ecs.EachEntityPointerCallback<T0, T1> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseSharedUnmanaged(i), field1.PointerSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, Ecs.EachEntityPointerCallback<T0, T1> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerManaged(i), field1.PointerManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, Ecs.EachEntityPointerCallback<T0, T1> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSharedManaged(i), field1.PointerSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, Ecs.EachEntityPointerCallback<T0, T1> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseManaged(i), field1.PointerSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, Ecs.EachEntityPointerCallback<T0, T1> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseSharedManaged(i), field1.PointerSparseSharedManaged(i));
+        }
     }
 
     /// <summary>
@@ -185,15 +811,93 @@ public static void Each<T0, T1>(Iter it, Ecs.EachIterPointerCallback<T0, T1> cal
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1);
+        IterationTechnique flags = it.GetIterationTechnique(2);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1])
-            callback(it, i, (T0*)pointer0, (T1*)pointer1);
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0, ref field1);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0, ref field1);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0, ref field1);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0, ref field1);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0, ref field1);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0, ref field1);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0, ref field1);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0, ref field1);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, Ecs.EachIterPointerCallback<T0, T1> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerUnmanaged(i), field1.PointerUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, Ecs.EachIterPointerCallback<T0, T1> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSharedUnmanaged(i), field1.PointerSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, Ecs.EachIterPointerCallback<T0, T1> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSparseUnmanaged(i), field1.PointerSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, Ecs.EachIterPointerCallback<T0, T1> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSparseSharedUnmanaged(i), field1.PointerSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, Ecs.EachIterPointerCallback<T0, T1> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerManaged(i), field1.PointerManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, Ecs.EachIterPointerCallback<T0, T1> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSharedManaged(i), field1.PointerSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, Ecs.EachIterPointerCallback<T0, T1> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSparseManaged(i), field1.PointerSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, Ecs.EachIterPointerCallback<T0, T1> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSparseSharedManaged(i), field1.PointerSparseSharedManaged(i));
+        }
     }
 
     /// <summary>
@@ -206,15 +910,93 @@ public static void Each<T0, T1>(Iter it, delegate*<T0*, T1*, void> callback)
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1);
+        IterationTechnique flags = it.GetIterationTechnique(2);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1])
-            callback((T0*)pointer0, (T1*)pointer1);
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0, ref field1);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0, ref field1);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0, ref field1);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0, ref field1);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0, ref field1);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0, ref field1);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0, ref field1);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0, ref field1);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, delegate*<T0*, T1*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerUnmanaged(i), field1.PointerUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, delegate*<T0*, T1*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSharedUnmanaged(i), field1.PointerSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, delegate*<T0*, T1*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSparseUnmanaged(i), field1.PointerSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, delegate*<T0*, T1*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSparseSharedUnmanaged(i), field1.PointerSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, delegate*<T0*, T1*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerManaged(i), field1.PointerManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, delegate*<T0*, T1*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSharedManaged(i), field1.PointerSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, delegate*<T0*, T1*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSparseManaged(i), field1.PointerSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, delegate*<T0*, T1*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSparseSharedManaged(i), field1.PointerSparseSharedManaged(i));
+        }
     }
 
     /// <summary>
@@ -227,15 +1009,93 @@ public static void Each<T0, T1>(Iter it, delegate*<Entity, T0*, T1*, void> callb
     {
         int count = it.Handle->count; Ecs.Assert(it.Handle->count > 0, "No entities returned, use Iter() or Each() without the entity argument instead.");
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1);
+        IterationTechnique flags = it.GetIterationTechnique(2);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1])
-            callback(new Entity(it.Handle->world, it.Handle->entities[i]), (T0*)pointer0, (T1*)pointer1);
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0, ref field1);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0, ref field1);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0, ref field1);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0, ref field1);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0, ref field1);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0, ref field1);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0, ref field1);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0, ref field1);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, delegate*<Entity, T0*, T1*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerUnmanaged(i), field1.PointerUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, delegate*<Entity, T0*, T1*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSharedUnmanaged(i), field1.PointerSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, delegate*<Entity, T0*, T1*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseUnmanaged(i), field1.PointerSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, delegate*<Entity, T0*, T1*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseSharedUnmanaged(i), field1.PointerSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, delegate*<Entity, T0*, T1*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerManaged(i), field1.PointerManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, delegate*<Entity, T0*, T1*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSharedManaged(i), field1.PointerSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, delegate*<Entity, T0*, T1*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseManaged(i), field1.PointerSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, delegate*<Entity, T0*, T1*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseSharedManaged(i), field1.PointerSparseSharedManaged(i));
+        }
     }
 
     /// <summary>
@@ -248,14 +1108,92 @@ public static void Each<T0, T1>(Iter it, delegate*<Iter, int, T0*, T1*, void> ca
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1);
+        IterationTechnique flags = it.GetIterationTechnique(2);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1])
-            callback(it, i, (T0*)pointer0, (T1*)pointer1);
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0, ref field1);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0, ref field1);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0, ref field1);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0, ref field1);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0, ref field1);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0, ref field1);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0, ref field1);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0, ref field1);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerUnmanaged(i), field1.PointerUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSharedUnmanaged(i), field1.PointerSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSparseUnmanaged(i), field1.PointerSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSparseSharedUnmanaged(i), field1.PointerSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, delegate*<Iter, int, T0*, T1*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerManaged(i), field1.PointerManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSharedManaged(i), field1.PointerSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSparseManaged(i), field1.PointerSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSparseSharedManaged(i), field1.PointerSparseSharedManaged(i));
+        }
     }
 }
\ No newline at end of file
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/Invoker/Each/Iterator/T3.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/Invoker/Each/Iterator/T3.g.cs
index 766bd6a7..17c5033a 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/Invoker/Each/Iterator/T3.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/Invoker/Each/Iterator/T3.g.cs
@@ -1,5 +1,7 @@
 // Each/Iterator/T3.g.cs
 // File was auto-generated by /_/src/Flecs.NET.Codegen/Generators/Invoker.cs
+using System;
+using System.Runtime.CompilerServices;
 using Flecs.NET.Utilities;
 using static Flecs.NET.Bindings.flecs;
 
@@ -17,15 +19,93 @@ public static void Each<T0, T1, T2>(Iter it, Ecs.EachRefCallback<T0, T1, T2> cal
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2);
+        IterationTechnique flags = it.GetIterationTechnique(3);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2])
-            callback(ref Managed.GetTypeRef<T0>(pointer0), ref Managed.GetTypeRef<T1>(pointer1), ref Managed.GetTypeRef<T2>(pointer2));
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0, ref field1, ref field2);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0, ref field1, ref field2);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0, ref field1, ref field2);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0, ref field1, ref field2);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, Ecs.EachRefCallback<T0, T1, T2> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefUnmanaged(i), ref field1.RefUnmanaged(i), ref field2.RefUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, Ecs.EachRefCallback<T0, T1, T2> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSharedUnmanaged(i), ref field1.RefSharedUnmanaged(i), ref field2.RefSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, Ecs.EachRefCallback<T0, T1, T2> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSparseUnmanaged(i), ref field1.RefSparseUnmanaged(i), ref field2.RefSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, Ecs.EachRefCallback<T0, T1, T2> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSparseSharedUnmanaged(i), ref field1.RefSparseSharedUnmanaged(i), ref field2.RefSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, Ecs.EachRefCallback<T0, T1, T2> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefManaged(i), ref field1.RefManaged(i), ref field2.RefManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, Ecs.EachRefCallback<T0, T1, T2> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSharedManaged(i), ref field1.RefSharedManaged(i), ref field2.RefSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, Ecs.EachRefCallback<T0, T1, T2> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSparseManaged(i), ref field1.RefSparseManaged(i), ref field2.RefSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, Ecs.EachRefCallback<T0, T1, T2> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSparseSharedManaged(i), ref field1.RefSparseSharedManaged(i), ref field2.RefSparseSharedManaged(i));
+        }
     }
 
     /// <summary>
@@ -38,15 +118,93 @@ public static void Each<T0, T1, T2>(Iter it, Ecs.EachEntityRefCallback<T0, T1, T
     {
         int count = it.Handle->count; Ecs.Assert(it.Handle->count > 0, "No entities returned, use Iter() or Each() without the entity argument instead.");
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2);
+        IterationTechnique flags = it.GetIterationTechnique(3);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2])
-            callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref Managed.GetTypeRef<T0>(pointer0), ref Managed.GetTypeRef<T1>(pointer1), ref Managed.GetTypeRef<T2>(pointer2));
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0, ref field1, ref field2);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0, ref field1, ref field2);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0, ref field1, ref field2);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0, ref field1, ref field2);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, Ecs.EachEntityRefCallback<T0, T1, T2> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefUnmanaged(i), ref field1.RefUnmanaged(i), ref field2.RefUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, Ecs.EachEntityRefCallback<T0, T1, T2> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSharedUnmanaged(i), ref field1.RefSharedUnmanaged(i), ref field2.RefSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, Ecs.EachEntityRefCallback<T0, T1, T2> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseUnmanaged(i), ref field1.RefSparseUnmanaged(i), ref field2.RefSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, Ecs.EachEntityRefCallback<T0, T1, T2> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseSharedUnmanaged(i), ref field1.RefSparseSharedUnmanaged(i), ref field2.RefSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, Ecs.EachEntityRefCallback<T0, T1, T2> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefManaged(i), ref field1.RefManaged(i), ref field2.RefManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, Ecs.EachEntityRefCallback<T0, T1, T2> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSharedManaged(i), ref field1.RefSharedManaged(i), ref field2.RefSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, Ecs.EachEntityRefCallback<T0, T1, T2> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseManaged(i), ref field1.RefSparseManaged(i), ref field2.RefSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, Ecs.EachEntityRefCallback<T0, T1, T2> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseSharedManaged(i), ref field1.RefSparseSharedManaged(i), ref field2.RefSparseSharedManaged(i));
+        }
     }
 
     /// <summary>
@@ -59,15 +217,93 @@ public static void Each<T0, T1, T2>(Iter it, Ecs.EachIterRefCallback<T0, T1, T2>
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2);
+        IterationTechnique flags = it.GetIterationTechnique(3);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2])
-            callback(it, i, ref Managed.GetTypeRef<T0>(pointer0), ref Managed.GetTypeRef<T1>(pointer1), ref Managed.GetTypeRef<T2>(pointer2));
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0, ref field1, ref field2);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0, ref field1, ref field2);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0, ref field1, ref field2);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0, ref field1, ref field2);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, Ecs.EachIterRefCallback<T0, T1, T2> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefUnmanaged(i), ref field1.RefUnmanaged(i), ref field2.RefUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, Ecs.EachIterRefCallback<T0, T1, T2> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSharedUnmanaged(i), ref field1.RefSharedUnmanaged(i), ref field2.RefSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, Ecs.EachIterRefCallback<T0, T1, T2> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSparseUnmanaged(i), ref field1.RefSparseUnmanaged(i), ref field2.RefSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, Ecs.EachIterRefCallback<T0, T1, T2> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSparseSharedUnmanaged(i), ref field1.RefSparseSharedUnmanaged(i), ref field2.RefSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, Ecs.EachIterRefCallback<T0, T1, T2> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefManaged(i), ref field1.RefManaged(i), ref field2.RefManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, Ecs.EachIterRefCallback<T0, T1, T2> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSharedManaged(i), ref field1.RefSharedManaged(i), ref field2.RefSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, Ecs.EachIterRefCallback<T0, T1, T2> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSparseManaged(i), ref field1.RefSparseManaged(i), ref field2.RefSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, Ecs.EachIterRefCallback<T0, T1, T2> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSparseSharedManaged(i), ref field1.RefSparseSharedManaged(i), ref field2.RefSparseSharedManaged(i));
+        }
     }
 
     /// <summary>
@@ -80,15 +316,93 @@ public static void Each<T0, T1, T2>(Iter it, delegate*<ref T0, ref T1, ref T2, v
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2);
+        IterationTechnique flags = it.GetIterationTechnique(3);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2])
-            callback(ref Managed.GetTypeRef<T0>(pointer0), ref Managed.GetTypeRef<T1>(pointer1), ref Managed.GetTypeRef<T2>(pointer2));
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0, ref field1, ref field2);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0, ref field1, ref field2);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0, ref field1, ref field2);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0, ref field1, ref field2);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefUnmanaged(i), ref field1.RefUnmanaged(i), ref field2.RefUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSharedUnmanaged(i), ref field1.RefSharedUnmanaged(i), ref field2.RefSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSparseUnmanaged(i), ref field1.RefSparseUnmanaged(i), ref field2.RefSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSparseSharedUnmanaged(i), ref field1.RefSparseSharedUnmanaged(i), ref field2.RefSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, delegate*<ref T0, ref T1, ref T2, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefManaged(i), ref field1.RefManaged(i), ref field2.RefManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSharedManaged(i), ref field1.RefSharedManaged(i), ref field2.RefSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSparseManaged(i), ref field1.RefSparseManaged(i), ref field2.RefSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSparseSharedManaged(i), ref field1.RefSparseSharedManaged(i), ref field2.RefSparseSharedManaged(i));
+        }
     }
 
     /// <summary>
@@ -101,15 +415,93 @@ public static void Each<T0, T1, T2>(Iter it, delegate*<Entity, ref T0, ref T1, r
     {
         int count = it.Handle->count; Ecs.Assert(it.Handle->count > 0, "No entities returned, use Iter() or Each() without the entity argument instead.");
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2);
+        IterationTechnique flags = it.GetIterationTechnique(3);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2])
-            callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref Managed.GetTypeRef<T0>(pointer0), ref Managed.GetTypeRef<T1>(pointer1), ref Managed.GetTypeRef<T2>(pointer2));
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0, ref field1, ref field2);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0, ref field1, ref field2);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0, ref field1, ref field2);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0, ref field1, ref field2);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefUnmanaged(i), ref field1.RefUnmanaged(i), ref field2.RefUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSharedUnmanaged(i), ref field1.RefSharedUnmanaged(i), ref field2.RefSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseUnmanaged(i), ref field1.RefSparseUnmanaged(i), ref field2.RefSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseSharedUnmanaged(i), ref field1.RefSparseSharedUnmanaged(i), ref field2.RefSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefManaged(i), ref field1.RefManaged(i), ref field2.RefManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSharedManaged(i), ref field1.RefSharedManaged(i), ref field2.RefSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseManaged(i), ref field1.RefSparseManaged(i), ref field2.RefSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseSharedManaged(i), ref field1.RefSparseSharedManaged(i), ref field2.RefSparseSharedManaged(i));
+        }
     }
 
     /// <summary>
@@ -122,15 +514,93 @@ public static void Each<T0, T1, T2>(Iter it, delegate*<Iter, int, ref T0, ref T1
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2);
+        IterationTechnique flags = it.GetIterationTechnique(3);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2])
-            callback(it, i, ref Managed.GetTypeRef<T0>(pointer0), ref Managed.GetTypeRef<T1>(pointer1), ref Managed.GetTypeRef<T2>(pointer2));
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0, ref field1, ref field2);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0, ref field1, ref field2);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0, ref field1, ref field2);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0, ref field1, ref field2);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefUnmanaged(i), ref field1.RefUnmanaged(i), ref field2.RefUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSharedUnmanaged(i), ref field1.RefSharedUnmanaged(i), ref field2.RefSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSparseUnmanaged(i), ref field1.RefSparseUnmanaged(i), ref field2.RefSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSparseSharedUnmanaged(i), ref field1.RefSparseSharedUnmanaged(i), ref field2.RefSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefManaged(i), ref field1.RefManaged(i), ref field2.RefManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSharedManaged(i), ref field1.RefSharedManaged(i), ref field2.RefSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSparseManaged(i), ref field1.RefSparseManaged(i), ref field2.RefSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSparseSharedManaged(i), ref field1.RefSparseSharedManaged(i), ref field2.RefSparseSharedManaged(i));
+        }
     }
 
     /// <summary>
@@ -143,15 +613,93 @@ public static void Each<T0, T1, T2>(Iter it, Ecs.EachPointerCallback<T0, T1, T2>
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2);
+        IterationTechnique flags = it.GetIterationTechnique(3);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2])
-            callback((T0*)pointer0, (T1*)pointer1, (T2*)pointer2);
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0, ref field1, ref field2);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0, ref field1, ref field2);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0, ref field1, ref field2);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0, ref field1, ref field2);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, Ecs.EachPointerCallback<T0, T1, T2> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerUnmanaged(i), field1.PointerUnmanaged(i), field2.PointerUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, Ecs.EachPointerCallback<T0, T1, T2> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSharedUnmanaged(i), field1.PointerSharedUnmanaged(i), field2.PointerSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, Ecs.EachPointerCallback<T0, T1, T2> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSparseUnmanaged(i), field1.PointerSparseUnmanaged(i), field2.PointerSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, Ecs.EachPointerCallback<T0, T1, T2> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSparseSharedUnmanaged(i), field1.PointerSparseSharedUnmanaged(i), field2.PointerSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, Ecs.EachPointerCallback<T0, T1, T2> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerManaged(i), field1.PointerManaged(i), field2.PointerManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, Ecs.EachPointerCallback<T0, T1, T2> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSharedManaged(i), field1.PointerSharedManaged(i), field2.PointerSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, Ecs.EachPointerCallback<T0, T1, T2> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSparseManaged(i), field1.PointerSparseManaged(i), field2.PointerSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, Ecs.EachPointerCallback<T0, T1, T2> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSparseSharedManaged(i), field1.PointerSparseSharedManaged(i), field2.PointerSparseSharedManaged(i));
+        }
     }
 
     /// <summary>
@@ -164,15 +712,93 @@ public static void Each<T0, T1, T2>(Iter it, Ecs.EachEntityPointerCallback<T0, T
     {
         int count = it.Handle->count; Ecs.Assert(it.Handle->count > 0, "No entities returned, use Iter() or Each() without the entity argument instead.");
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2);
+        IterationTechnique flags = it.GetIterationTechnique(3);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2])
-            callback(new Entity(it.Handle->world, it.Handle->entities[i]), (T0*)pointer0, (T1*)pointer1, (T2*)pointer2);
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0, ref field1, ref field2);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0, ref field1, ref field2);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0, ref field1, ref field2);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0, ref field1, ref field2);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, Ecs.EachEntityPointerCallback<T0, T1, T2> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerUnmanaged(i), field1.PointerUnmanaged(i), field2.PointerUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, Ecs.EachEntityPointerCallback<T0, T1, T2> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSharedUnmanaged(i), field1.PointerSharedUnmanaged(i), field2.PointerSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, Ecs.EachEntityPointerCallback<T0, T1, T2> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseUnmanaged(i), field1.PointerSparseUnmanaged(i), field2.PointerSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, Ecs.EachEntityPointerCallback<T0, T1, T2> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseSharedUnmanaged(i), field1.PointerSparseSharedUnmanaged(i), field2.PointerSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, Ecs.EachEntityPointerCallback<T0, T1, T2> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerManaged(i), field1.PointerManaged(i), field2.PointerManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, Ecs.EachEntityPointerCallback<T0, T1, T2> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSharedManaged(i), field1.PointerSharedManaged(i), field2.PointerSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, Ecs.EachEntityPointerCallback<T0, T1, T2> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseManaged(i), field1.PointerSparseManaged(i), field2.PointerSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, Ecs.EachEntityPointerCallback<T0, T1, T2> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseSharedManaged(i), field1.PointerSparseSharedManaged(i), field2.PointerSparseSharedManaged(i));
+        }
     }
 
     /// <summary>
@@ -185,15 +811,93 @@ public static void Each<T0, T1, T2>(Iter it, Ecs.EachIterPointerCallback<T0, T1,
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2);
+        IterationTechnique flags = it.GetIterationTechnique(3);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2])
-            callback(it, i, (T0*)pointer0, (T1*)pointer1, (T2*)pointer2);
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0, ref field1, ref field2);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0, ref field1, ref field2);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0, ref field1, ref field2);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0, ref field1, ref field2);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, Ecs.EachIterPointerCallback<T0, T1, T2> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerUnmanaged(i), field1.PointerUnmanaged(i), field2.PointerUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, Ecs.EachIterPointerCallback<T0, T1, T2> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSharedUnmanaged(i), field1.PointerSharedUnmanaged(i), field2.PointerSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, Ecs.EachIterPointerCallback<T0, T1, T2> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSparseUnmanaged(i), field1.PointerSparseUnmanaged(i), field2.PointerSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, Ecs.EachIterPointerCallback<T0, T1, T2> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSparseSharedUnmanaged(i), field1.PointerSparseSharedUnmanaged(i), field2.PointerSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, Ecs.EachIterPointerCallback<T0, T1, T2> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerManaged(i), field1.PointerManaged(i), field2.PointerManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, Ecs.EachIterPointerCallback<T0, T1, T2> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSharedManaged(i), field1.PointerSharedManaged(i), field2.PointerSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, Ecs.EachIterPointerCallback<T0, T1, T2> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSparseManaged(i), field1.PointerSparseManaged(i), field2.PointerSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, Ecs.EachIterPointerCallback<T0, T1, T2> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSparseSharedManaged(i), field1.PointerSparseSharedManaged(i), field2.PointerSparseSharedManaged(i));
+        }
     }
 
     /// <summary>
@@ -206,15 +910,93 @@ public static void Each<T0, T1, T2>(Iter it, delegate*<T0*, T1*, T2*, void> call
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2);
+        IterationTechnique flags = it.GetIterationTechnique(3);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2])
-            callback((T0*)pointer0, (T1*)pointer1, (T2*)pointer2);
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0, ref field1, ref field2);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0, ref field1, ref field2);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0, ref field1, ref field2);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0, ref field1, ref field2);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, delegate*<T0*, T1*, T2*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerUnmanaged(i), field1.PointerUnmanaged(i), field2.PointerUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, delegate*<T0*, T1*, T2*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSharedUnmanaged(i), field1.PointerSharedUnmanaged(i), field2.PointerSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, delegate*<T0*, T1*, T2*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSparseUnmanaged(i), field1.PointerSparseUnmanaged(i), field2.PointerSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, delegate*<T0*, T1*, T2*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSparseSharedUnmanaged(i), field1.PointerSparseSharedUnmanaged(i), field2.PointerSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, delegate*<T0*, T1*, T2*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerManaged(i), field1.PointerManaged(i), field2.PointerManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, delegate*<T0*, T1*, T2*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSharedManaged(i), field1.PointerSharedManaged(i), field2.PointerSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, delegate*<T0*, T1*, T2*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSparseManaged(i), field1.PointerSparseManaged(i), field2.PointerSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, delegate*<T0*, T1*, T2*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSparseSharedManaged(i), field1.PointerSparseSharedManaged(i), field2.PointerSparseSharedManaged(i));
+        }
     }
 
     /// <summary>
@@ -227,15 +1009,93 @@ public static void Each<T0, T1, T2>(Iter it, delegate*<Entity, T0*, T1*, T2*, vo
     {
         int count = it.Handle->count; Ecs.Assert(it.Handle->count > 0, "No entities returned, use Iter() or Each() without the entity argument instead.");
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2);
+        IterationTechnique flags = it.GetIterationTechnique(3);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2])
-            callback(new Entity(it.Handle->world, it.Handle->entities[i]), (T0*)pointer0, (T1*)pointer1, (T2*)pointer2);
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0, ref field1, ref field2);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0, ref field1, ref field2);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0, ref field1, ref field2);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0, ref field1, ref field2);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerUnmanaged(i), field1.PointerUnmanaged(i), field2.PointerUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSharedUnmanaged(i), field1.PointerSharedUnmanaged(i), field2.PointerSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseUnmanaged(i), field1.PointerSparseUnmanaged(i), field2.PointerSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseSharedUnmanaged(i), field1.PointerSparseSharedUnmanaged(i), field2.PointerSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerManaged(i), field1.PointerManaged(i), field2.PointerManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSharedManaged(i), field1.PointerSharedManaged(i), field2.PointerSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseManaged(i), field1.PointerSparseManaged(i), field2.PointerSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseSharedManaged(i), field1.PointerSparseSharedManaged(i), field2.PointerSparseSharedManaged(i));
+        }
     }
 
     /// <summary>
@@ -248,14 +1108,92 @@ public static void Each<T0, T1, T2>(Iter it, delegate*<Iter, int, T0*, T1*, T2*,
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2);
+        IterationTechnique flags = it.GetIterationTechnique(3);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2])
-            callback(it, i, (T0*)pointer0, (T1*)pointer1, (T2*)pointer2);
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0, ref field1, ref field2);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0, ref field1, ref field2);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0, ref field1, ref field2);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0, ref field1, ref field2);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerUnmanaged(i), field1.PointerUnmanaged(i), field2.PointerUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSharedUnmanaged(i), field1.PointerSharedUnmanaged(i), field2.PointerSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSparseUnmanaged(i), field1.PointerSparseUnmanaged(i), field2.PointerSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSparseSharedUnmanaged(i), field1.PointerSparseSharedUnmanaged(i), field2.PointerSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerManaged(i), field1.PointerManaged(i), field2.PointerManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSharedManaged(i), field1.PointerSharedManaged(i), field2.PointerSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSparseManaged(i), field1.PointerSparseManaged(i), field2.PointerSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSparseSharedManaged(i), field1.PointerSparseSharedManaged(i), field2.PointerSparseSharedManaged(i));
+        }
     }
 }
\ No newline at end of file
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/Invoker/Each/Iterator/T4.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/Invoker/Each/Iterator/T4.g.cs
index 8987a2a5..9cf37b1c 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/Invoker/Each/Iterator/T4.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/Invoker/Each/Iterator/T4.g.cs
@@ -1,5 +1,7 @@
 // Each/Iterator/T4.g.cs
 // File was auto-generated by /_/src/Flecs.NET.Codegen/Generators/Invoker.cs
+using System;
+using System.Runtime.CompilerServices;
 using Flecs.NET.Utilities;
 using static Flecs.NET.Bindings.flecs;
 
@@ -17,15 +19,93 @@ public static void Each<T0, T1, T2, T3>(Iter it, Ecs.EachRefCallback<T0, T1, T2,
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3);
+        IterationTechnique flags = it.GetIterationTechnique(4);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3])
-            callback(ref Managed.GetTypeRef<T0>(pointer0), ref Managed.GetTypeRef<T1>(pointer1), ref Managed.GetTypeRef<T2>(pointer2), ref Managed.GetTypeRef<T3>(pointer3));
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, Ecs.EachRefCallback<T0, T1, T2, T3> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefUnmanaged(i), ref field1.RefUnmanaged(i), ref field2.RefUnmanaged(i), ref field3.RefUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, Ecs.EachRefCallback<T0, T1, T2, T3> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSharedUnmanaged(i), ref field1.RefSharedUnmanaged(i), ref field2.RefSharedUnmanaged(i), ref field3.RefSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, Ecs.EachRefCallback<T0, T1, T2, T3> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSparseUnmanaged(i), ref field1.RefSparseUnmanaged(i), ref field2.RefSparseUnmanaged(i), ref field3.RefSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, Ecs.EachRefCallback<T0, T1, T2, T3> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSparseSharedUnmanaged(i), ref field1.RefSparseSharedUnmanaged(i), ref field2.RefSparseSharedUnmanaged(i), ref field3.RefSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, Ecs.EachRefCallback<T0, T1, T2, T3> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefManaged(i), ref field1.RefManaged(i), ref field2.RefManaged(i), ref field3.RefManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, Ecs.EachRefCallback<T0, T1, T2, T3> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSharedManaged(i), ref field1.RefSharedManaged(i), ref field2.RefSharedManaged(i), ref field3.RefSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, Ecs.EachRefCallback<T0, T1, T2, T3> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSparseManaged(i), ref field1.RefSparseManaged(i), ref field2.RefSparseManaged(i), ref field3.RefSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, Ecs.EachRefCallback<T0, T1, T2, T3> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSparseSharedManaged(i), ref field1.RefSparseSharedManaged(i), ref field2.RefSparseSharedManaged(i), ref field3.RefSparseSharedManaged(i));
+        }
     }
 
     /// <summary>
@@ -38,15 +118,93 @@ public static void Each<T0, T1, T2, T3>(Iter it, Ecs.EachEntityRefCallback<T0, T
     {
         int count = it.Handle->count; Ecs.Assert(it.Handle->count > 0, "No entities returned, use Iter() or Each() without the entity argument instead.");
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3);
+        IterationTechnique flags = it.GetIterationTechnique(4);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3])
-            callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref Managed.GetTypeRef<T0>(pointer0), ref Managed.GetTypeRef<T1>(pointer1), ref Managed.GetTypeRef<T2>(pointer2), ref Managed.GetTypeRef<T3>(pointer3));
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, Ecs.EachEntityRefCallback<T0, T1, T2, T3> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefUnmanaged(i), ref field1.RefUnmanaged(i), ref field2.RefUnmanaged(i), ref field3.RefUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, Ecs.EachEntityRefCallback<T0, T1, T2, T3> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSharedUnmanaged(i), ref field1.RefSharedUnmanaged(i), ref field2.RefSharedUnmanaged(i), ref field3.RefSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, Ecs.EachEntityRefCallback<T0, T1, T2, T3> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseUnmanaged(i), ref field1.RefSparseUnmanaged(i), ref field2.RefSparseUnmanaged(i), ref field3.RefSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, Ecs.EachEntityRefCallback<T0, T1, T2, T3> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseSharedUnmanaged(i), ref field1.RefSparseSharedUnmanaged(i), ref field2.RefSparseSharedUnmanaged(i), ref field3.RefSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, Ecs.EachEntityRefCallback<T0, T1, T2, T3> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefManaged(i), ref field1.RefManaged(i), ref field2.RefManaged(i), ref field3.RefManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, Ecs.EachEntityRefCallback<T0, T1, T2, T3> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSharedManaged(i), ref field1.RefSharedManaged(i), ref field2.RefSharedManaged(i), ref field3.RefSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, Ecs.EachEntityRefCallback<T0, T1, T2, T3> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseManaged(i), ref field1.RefSparseManaged(i), ref field2.RefSparseManaged(i), ref field3.RefSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, Ecs.EachEntityRefCallback<T0, T1, T2, T3> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseSharedManaged(i), ref field1.RefSparseSharedManaged(i), ref field2.RefSparseSharedManaged(i), ref field3.RefSparseSharedManaged(i));
+        }
     }
 
     /// <summary>
@@ -59,15 +217,93 @@ public static void Each<T0, T1, T2, T3>(Iter it, Ecs.EachIterRefCallback<T0, T1,
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3);
+        IterationTechnique flags = it.GetIterationTechnique(4);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3])
-            callback(it, i, ref Managed.GetTypeRef<T0>(pointer0), ref Managed.GetTypeRef<T1>(pointer1), ref Managed.GetTypeRef<T2>(pointer2), ref Managed.GetTypeRef<T3>(pointer3));
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, Ecs.EachIterRefCallback<T0, T1, T2, T3> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefUnmanaged(i), ref field1.RefUnmanaged(i), ref field2.RefUnmanaged(i), ref field3.RefUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, Ecs.EachIterRefCallback<T0, T1, T2, T3> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSharedUnmanaged(i), ref field1.RefSharedUnmanaged(i), ref field2.RefSharedUnmanaged(i), ref field3.RefSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, Ecs.EachIterRefCallback<T0, T1, T2, T3> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSparseUnmanaged(i), ref field1.RefSparseUnmanaged(i), ref field2.RefSparseUnmanaged(i), ref field3.RefSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, Ecs.EachIterRefCallback<T0, T1, T2, T3> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSparseSharedUnmanaged(i), ref field1.RefSparseSharedUnmanaged(i), ref field2.RefSparseSharedUnmanaged(i), ref field3.RefSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, Ecs.EachIterRefCallback<T0, T1, T2, T3> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefManaged(i), ref field1.RefManaged(i), ref field2.RefManaged(i), ref field3.RefManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, Ecs.EachIterRefCallback<T0, T1, T2, T3> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSharedManaged(i), ref field1.RefSharedManaged(i), ref field2.RefSharedManaged(i), ref field3.RefSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, Ecs.EachIterRefCallback<T0, T1, T2, T3> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSparseManaged(i), ref field1.RefSparseManaged(i), ref field2.RefSparseManaged(i), ref field3.RefSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, Ecs.EachIterRefCallback<T0, T1, T2, T3> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSparseSharedManaged(i), ref field1.RefSparseSharedManaged(i), ref field2.RefSparseSharedManaged(i), ref field3.RefSparseSharedManaged(i));
+        }
     }
 
     /// <summary>
@@ -80,15 +316,93 @@ public static void Each<T0, T1, T2, T3>(Iter it, delegate*<ref T0, ref T1, ref T
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3);
+        IterationTechnique flags = it.GetIterationTechnique(4);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3])
-            callback(ref Managed.GetTypeRef<T0>(pointer0), ref Managed.GetTypeRef<T1>(pointer1), ref Managed.GetTypeRef<T2>(pointer2), ref Managed.GetTypeRef<T3>(pointer3));
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefUnmanaged(i), ref field1.RefUnmanaged(i), ref field2.RefUnmanaged(i), ref field3.RefUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSharedUnmanaged(i), ref field1.RefSharedUnmanaged(i), ref field2.RefSharedUnmanaged(i), ref field3.RefSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSparseUnmanaged(i), ref field1.RefSparseUnmanaged(i), ref field2.RefSparseUnmanaged(i), ref field3.RefSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSparseSharedUnmanaged(i), ref field1.RefSparseSharedUnmanaged(i), ref field2.RefSparseSharedUnmanaged(i), ref field3.RefSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefManaged(i), ref field1.RefManaged(i), ref field2.RefManaged(i), ref field3.RefManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSharedManaged(i), ref field1.RefSharedManaged(i), ref field2.RefSharedManaged(i), ref field3.RefSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSparseManaged(i), ref field1.RefSparseManaged(i), ref field2.RefSparseManaged(i), ref field3.RefSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSparseSharedManaged(i), ref field1.RefSparseSharedManaged(i), ref field2.RefSparseSharedManaged(i), ref field3.RefSparseSharedManaged(i));
+        }
     }
 
     /// <summary>
@@ -101,15 +415,93 @@ public static void Each<T0, T1, T2, T3>(Iter it, delegate*<Entity, ref T0, ref T
     {
         int count = it.Handle->count; Ecs.Assert(it.Handle->count > 0, "No entities returned, use Iter() or Each() without the entity argument instead.");
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3);
+        IterationTechnique flags = it.GetIterationTechnique(4);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3])
-            callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref Managed.GetTypeRef<T0>(pointer0), ref Managed.GetTypeRef<T1>(pointer1), ref Managed.GetTypeRef<T2>(pointer2), ref Managed.GetTypeRef<T3>(pointer3));
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefUnmanaged(i), ref field1.RefUnmanaged(i), ref field2.RefUnmanaged(i), ref field3.RefUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSharedUnmanaged(i), ref field1.RefSharedUnmanaged(i), ref field2.RefSharedUnmanaged(i), ref field3.RefSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseUnmanaged(i), ref field1.RefSparseUnmanaged(i), ref field2.RefSparseUnmanaged(i), ref field3.RefSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseSharedUnmanaged(i), ref field1.RefSparseSharedUnmanaged(i), ref field2.RefSparseSharedUnmanaged(i), ref field3.RefSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefManaged(i), ref field1.RefManaged(i), ref field2.RefManaged(i), ref field3.RefManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSharedManaged(i), ref field1.RefSharedManaged(i), ref field2.RefSharedManaged(i), ref field3.RefSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseManaged(i), ref field1.RefSparseManaged(i), ref field2.RefSparseManaged(i), ref field3.RefSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseSharedManaged(i), ref field1.RefSparseSharedManaged(i), ref field2.RefSparseSharedManaged(i), ref field3.RefSparseSharedManaged(i));
+        }
     }
 
     /// <summary>
@@ -122,15 +514,93 @@ public static void Each<T0, T1, T2, T3>(Iter it, delegate*<Iter, int, ref T0, re
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3);
+        IterationTechnique flags = it.GetIterationTechnique(4);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3])
-            callback(it, i, ref Managed.GetTypeRef<T0>(pointer0), ref Managed.GetTypeRef<T1>(pointer1), ref Managed.GetTypeRef<T2>(pointer2), ref Managed.GetTypeRef<T3>(pointer3));
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefUnmanaged(i), ref field1.RefUnmanaged(i), ref field2.RefUnmanaged(i), ref field3.RefUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSharedUnmanaged(i), ref field1.RefSharedUnmanaged(i), ref field2.RefSharedUnmanaged(i), ref field3.RefSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSparseUnmanaged(i), ref field1.RefSparseUnmanaged(i), ref field2.RefSparseUnmanaged(i), ref field3.RefSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSparseSharedUnmanaged(i), ref field1.RefSparseSharedUnmanaged(i), ref field2.RefSparseSharedUnmanaged(i), ref field3.RefSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefManaged(i), ref field1.RefManaged(i), ref field2.RefManaged(i), ref field3.RefManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSharedManaged(i), ref field1.RefSharedManaged(i), ref field2.RefSharedManaged(i), ref field3.RefSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSparseManaged(i), ref field1.RefSparseManaged(i), ref field2.RefSparseManaged(i), ref field3.RefSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSparseSharedManaged(i), ref field1.RefSparseSharedManaged(i), ref field2.RefSparseSharedManaged(i), ref field3.RefSparseSharedManaged(i));
+        }
     }
 
     /// <summary>
@@ -143,15 +613,93 @@ public static void Each<T0, T1, T2, T3>(Iter it, Ecs.EachPointerCallback<T0, T1,
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3);
+        IterationTechnique flags = it.GetIterationTechnique(4);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3])
-            callback((T0*)pointer0, (T1*)pointer1, (T2*)pointer2, (T3*)pointer3);
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, Ecs.EachPointerCallback<T0, T1, T2, T3> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerUnmanaged(i), field1.PointerUnmanaged(i), field2.PointerUnmanaged(i), field3.PointerUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, Ecs.EachPointerCallback<T0, T1, T2, T3> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSharedUnmanaged(i), field1.PointerSharedUnmanaged(i), field2.PointerSharedUnmanaged(i), field3.PointerSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, Ecs.EachPointerCallback<T0, T1, T2, T3> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSparseUnmanaged(i), field1.PointerSparseUnmanaged(i), field2.PointerSparseUnmanaged(i), field3.PointerSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, Ecs.EachPointerCallback<T0, T1, T2, T3> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSparseSharedUnmanaged(i), field1.PointerSparseSharedUnmanaged(i), field2.PointerSparseSharedUnmanaged(i), field3.PointerSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, Ecs.EachPointerCallback<T0, T1, T2, T3> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerManaged(i), field1.PointerManaged(i), field2.PointerManaged(i), field3.PointerManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, Ecs.EachPointerCallback<T0, T1, T2, T3> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSharedManaged(i), field1.PointerSharedManaged(i), field2.PointerSharedManaged(i), field3.PointerSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, Ecs.EachPointerCallback<T0, T1, T2, T3> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSparseManaged(i), field1.PointerSparseManaged(i), field2.PointerSparseManaged(i), field3.PointerSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, Ecs.EachPointerCallback<T0, T1, T2, T3> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSparseSharedManaged(i), field1.PointerSparseSharedManaged(i), field2.PointerSparseSharedManaged(i), field3.PointerSparseSharedManaged(i));
+        }
     }
 
     /// <summary>
@@ -164,15 +712,93 @@ public static void Each<T0, T1, T2, T3>(Iter it, Ecs.EachEntityPointerCallback<T
     {
         int count = it.Handle->count; Ecs.Assert(it.Handle->count > 0, "No entities returned, use Iter() or Each() without the entity argument instead.");
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3);
+        IterationTechnique flags = it.GetIterationTechnique(4);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3])
-            callback(new Entity(it.Handle->world, it.Handle->entities[i]), (T0*)pointer0, (T1*)pointer1, (T2*)pointer2, (T3*)pointer3);
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, Ecs.EachEntityPointerCallback<T0, T1, T2, T3> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerUnmanaged(i), field1.PointerUnmanaged(i), field2.PointerUnmanaged(i), field3.PointerUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, Ecs.EachEntityPointerCallback<T0, T1, T2, T3> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSharedUnmanaged(i), field1.PointerSharedUnmanaged(i), field2.PointerSharedUnmanaged(i), field3.PointerSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, Ecs.EachEntityPointerCallback<T0, T1, T2, T3> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseUnmanaged(i), field1.PointerSparseUnmanaged(i), field2.PointerSparseUnmanaged(i), field3.PointerSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, Ecs.EachEntityPointerCallback<T0, T1, T2, T3> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseSharedUnmanaged(i), field1.PointerSparseSharedUnmanaged(i), field2.PointerSparseSharedUnmanaged(i), field3.PointerSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, Ecs.EachEntityPointerCallback<T0, T1, T2, T3> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerManaged(i), field1.PointerManaged(i), field2.PointerManaged(i), field3.PointerManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, Ecs.EachEntityPointerCallback<T0, T1, T2, T3> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSharedManaged(i), field1.PointerSharedManaged(i), field2.PointerSharedManaged(i), field3.PointerSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, Ecs.EachEntityPointerCallback<T0, T1, T2, T3> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseManaged(i), field1.PointerSparseManaged(i), field2.PointerSparseManaged(i), field3.PointerSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, Ecs.EachEntityPointerCallback<T0, T1, T2, T3> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseSharedManaged(i), field1.PointerSparseSharedManaged(i), field2.PointerSparseSharedManaged(i), field3.PointerSparseSharedManaged(i));
+        }
     }
 
     /// <summary>
@@ -185,15 +811,93 @@ public static void Each<T0, T1, T2, T3>(Iter it, Ecs.EachIterPointerCallback<T0,
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3);
+        IterationTechnique flags = it.GetIterationTechnique(4);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3])
-            callback(it, i, (T0*)pointer0, (T1*)pointer1, (T2*)pointer2, (T3*)pointer3);
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, Ecs.EachIterPointerCallback<T0, T1, T2, T3> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerUnmanaged(i), field1.PointerUnmanaged(i), field2.PointerUnmanaged(i), field3.PointerUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, Ecs.EachIterPointerCallback<T0, T1, T2, T3> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSharedUnmanaged(i), field1.PointerSharedUnmanaged(i), field2.PointerSharedUnmanaged(i), field3.PointerSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, Ecs.EachIterPointerCallback<T0, T1, T2, T3> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSparseUnmanaged(i), field1.PointerSparseUnmanaged(i), field2.PointerSparseUnmanaged(i), field3.PointerSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, Ecs.EachIterPointerCallback<T0, T1, T2, T3> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSparseSharedUnmanaged(i), field1.PointerSparseSharedUnmanaged(i), field2.PointerSparseSharedUnmanaged(i), field3.PointerSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, Ecs.EachIterPointerCallback<T0, T1, T2, T3> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerManaged(i), field1.PointerManaged(i), field2.PointerManaged(i), field3.PointerManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, Ecs.EachIterPointerCallback<T0, T1, T2, T3> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSharedManaged(i), field1.PointerSharedManaged(i), field2.PointerSharedManaged(i), field3.PointerSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, Ecs.EachIterPointerCallback<T0, T1, T2, T3> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSparseManaged(i), field1.PointerSparseManaged(i), field2.PointerSparseManaged(i), field3.PointerSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, Ecs.EachIterPointerCallback<T0, T1, T2, T3> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSparseSharedManaged(i), field1.PointerSparseSharedManaged(i), field2.PointerSparseSharedManaged(i), field3.PointerSparseSharedManaged(i));
+        }
     }
 
     /// <summary>
@@ -206,15 +910,93 @@ public static void Each<T0, T1, T2, T3>(Iter it, delegate*<T0*, T1*, T2*, T3*, v
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3);
+        IterationTechnique flags = it.GetIterationTechnique(4);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3])
-            callback((T0*)pointer0, (T1*)pointer1, (T2*)pointer2, (T3*)pointer3);
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerUnmanaged(i), field1.PointerUnmanaged(i), field2.PointerUnmanaged(i), field3.PointerUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSharedUnmanaged(i), field1.PointerSharedUnmanaged(i), field2.PointerSharedUnmanaged(i), field3.PointerSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSparseUnmanaged(i), field1.PointerSparseUnmanaged(i), field2.PointerSparseUnmanaged(i), field3.PointerSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSparseSharedUnmanaged(i), field1.PointerSparseSharedUnmanaged(i), field2.PointerSparseSharedUnmanaged(i), field3.PointerSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerManaged(i), field1.PointerManaged(i), field2.PointerManaged(i), field3.PointerManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSharedManaged(i), field1.PointerSharedManaged(i), field2.PointerSharedManaged(i), field3.PointerSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSparseManaged(i), field1.PointerSparseManaged(i), field2.PointerSparseManaged(i), field3.PointerSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSparseSharedManaged(i), field1.PointerSparseSharedManaged(i), field2.PointerSparseSharedManaged(i), field3.PointerSparseSharedManaged(i));
+        }
     }
 
     /// <summary>
@@ -227,15 +1009,93 @@ public static void Each<T0, T1, T2, T3>(Iter it, delegate*<Entity, T0*, T1*, T2*
     {
         int count = it.Handle->count; Ecs.Assert(it.Handle->count > 0, "No entities returned, use Iter() or Each() without the entity argument instead.");
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3);
+        IterationTechnique flags = it.GetIterationTechnique(4);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3])
-            callback(new Entity(it.Handle->world, it.Handle->entities[i]), (T0*)pointer0, (T1*)pointer1, (T2*)pointer2, (T3*)pointer3);
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerUnmanaged(i), field1.PointerUnmanaged(i), field2.PointerUnmanaged(i), field3.PointerUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSharedUnmanaged(i), field1.PointerSharedUnmanaged(i), field2.PointerSharedUnmanaged(i), field3.PointerSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseUnmanaged(i), field1.PointerSparseUnmanaged(i), field2.PointerSparseUnmanaged(i), field3.PointerSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseSharedUnmanaged(i), field1.PointerSparseSharedUnmanaged(i), field2.PointerSparseSharedUnmanaged(i), field3.PointerSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerManaged(i), field1.PointerManaged(i), field2.PointerManaged(i), field3.PointerManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSharedManaged(i), field1.PointerSharedManaged(i), field2.PointerSharedManaged(i), field3.PointerSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseManaged(i), field1.PointerSparseManaged(i), field2.PointerSparseManaged(i), field3.PointerSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseSharedManaged(i), field1.PointerSparseSharedManaged(i), field2.PointerSparseSharedManaged(i), field3.PointerSparseSharedManaged(i));
+        }
     }
 
     /// <summary>
@@ -248,14 +1108,92 @@ public static void Each<T0, T1, T2, T3>(Iter it, delegate*<Iter, int, T0*, T1*,
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3);
+        IterationTechnique flags = it.GetIterationTechnique(4);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3])
-            callback(it, i, (T0*)pointer0, (T1*)pointer1, (T2*)pointer2, (T3*)pointer3);
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerUnmanaged(i), field1.PointerUnmanaged(i), field2.PointerUnmanaged(i), field3.PointerUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSharedUnmanaged(i), field1.PointerSharedUnmanaged(i), field2.PointerSharedUnmanaged(i), field3.PointerSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSparseUnmanaged(i), field1.PointerSparseUnmanaged(i), field2.PointerSparseUnmanaged(i), field3.PointerSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSparseSharedUnmanaged(i), field1.PointerSparseSharedUnmanaged(i), field2.PointerSparseSharedUnmanaged(i), field3.PointerSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerManaged(i), field1.PointerManaged(i), field2.PointerManaged(i), field3.PointerManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSharedManaged(i), field1.PointerSharedManaged(i), field2.PointerSharedManaged(i), field3.PointerSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSparseManaged(i), field1.PointerSparseManaged(i), field2.PointerSparseManaged(i), field3.PointerSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSparseSharedManaged(i), field1.PointerSparseSharedManaged(i), field2.PointerSparseSharedManaged(i), field3.PointerSparseSharedManaged(i));
+        }
     }
 }
\ No newline at end of file
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/Invoker/Each/Iterator/T5.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/Invoker/Each/Iterator/T5.g.cs
index 6177839d..8222c569 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/Invoker/Each/Iterator/T5.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/Invoker/Each/Iterator/T5.g.cs
@@ -1,5 +1,7 @@
 // Each/Iterator/T5.g.cs
 // File was auto-generated by /_/src/Flecs.NET.Codegen/Generators/Invoker.cs
+using System;
+using System.Runtime.CompilerServices;
 using Flecs.NET.Utilities;
 using static Flecs.NET.Bindings.flecs;
 
@@ -17,15 +19,93 @@ public static void Each<T0, T1, T2, T3, T4>(Iter it, Ecs.EachRefCallback<T0, T1,
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4);
+        IterationTechnique flags = it.GetIterationTechnique(5);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4])
-            callback(ref Managed.GetTypeRef<T0>(pointer0), ref Managed.GetTypeRef<T1>(pointer1), ref Managed.GetTypeRef<T2>(pointer2), ref Managed.GetTypeRef<T3>(pointer3), ref Managed.GetTypeRef<T4>(pointer4));
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, Ecs.EachRefCallback<T0, T1, T2, T3, T4> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefUnmanaged(i), ref field1.RefUnmanaged(i), ref field2.RefUnmanaged(i), ref field3.RefUnmanaged(i), ref field4.RefUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, Ecs.EachRefCallback<T0, T1, T2, T3, T4> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSharedUnmanaged(i), ref field1.RefSharedUnmanaged(i), ref field2.RefSharedUnmanaged(i), ref field3.RefSharedUnmanaged(i), ref field4.RefSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, Ecs.EachRefCallback<T0, T1, T2, T3, T4> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSparseUnmanaged(i), ref field1.RefSparseUnmanaged(i), ref field2.RefSparseUnmanaged(i), ref field3.RefSparseUnmanaged(i), ref field4.RefSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, Ecs.EachRefCallback<T0, T1, T2, T3, T4> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSparseSharedUnmanaged(i), ref field1.RefSparseSharedUnmanaged(i), ref field2.RefSparseSharedUnmanaged(i), ref field3.RefSparseSharedUnmanaged(i), ref field4.RefSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, Ecs.EachRefCallback<T0, T1, T2, T3, T4> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefManaged(i), ref field1.RefManaged(i), ref field2.RefManaged(i), ref field3.RefManaged(i), ref field4.RefManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, Ecs.EachRefCallback<T0, T1, T2, T3, T4> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSharedManaged(i), ref field1.RefSharedManaged(i), ref field2.RefSharedManaged(i), ref field3.RefSharedManaged(i), ref field4.RefSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, Ecs.EachRefCallback<T0, T1, T2, T3, T4> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSparseManaged(i), ref field1.RefSparseManaged(i), ref field2.RefSparseManaged(i), ref field3.RefSparseManaged(i), ref field4.RefSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, Ecs.EachRefCallback<T0, T1, T2, T3, T4> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSparseSharedManaged(i), ref field1.RefSparseSharedManaged(i), ref field2.RefSparseSharedManaged(i), ref field3.RefSparseSharedManaged(i), ref field4.RefSparseSharedManaged(i));
+        }
     }
 
     /// <summary>
@@ -38,15 +118,93 @@ public static void Each<T0, T1, T2, T3, T4>(Iter it, Ecs.EachEntityRefCallback<T
     {
         int count = it.Handle->count; Ecs.Assert(it.Handle->count > 0, "No entities returned, use Iter() or Each() without the entity argument instead.");
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4);
+        IterationTechnique flags = it.GetIterationTechnique(5);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4])
-            callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref Managed.GetTypeRef<T0>(pointer0), ref Managed.GetTypeRef<T1>(pointer1), ref Managed.GetTypeRef<T2>(pointer2), ref Managed.GetTypeRef<T3>(pointer3), ref Managed.GetTypeRef<T4>(pointer4));
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefUnmanaged(i), ref field1.RefUnmanaged(i), ref field2.RefUnmanaged(i), ref field3.RefUnmanaged(i), ref field4.RefUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSharedUnmanaged(i), ref field1.RefSharedUnmanaged(i), ref field2.RefSharedUnmanaged(i), ref field3.RefSharedUnmanaged(i), ref field4.RefSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseUnmanaged(i), ref field1.RefSparseUnmanaged(i), ref field2.RefSparseUnmanaged(i), ref field3.RefSparseUnmanaged(i), ref field4.RefSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseSharedUnmanaged(i), ref field1.RefSparseSharedUnmanaged(i), ref field2.RefSparseSharedUnmanaged(i), ref field3.RefSparseSharedUnmanaged(i), ref field4.RefSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefManaged(i), ref field1.RefManaged(i), ref field2.RefManaged(i), ref field3.RefManaged(i), ref field4.RefManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSharedManaged(i), ref field1.RefSharedManaged(i), ref field2.RefSharedManaged(i), ref field3.RefSharedManaged(i), ref field4.RefSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseManaged(i), ref field1.RefSparseManaged(i), ref field2.RefSparseManaged(i), ref field3.RefSparseManaged(i), ref field4.RefSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseSharedManaged(i), ref field1.RefSparseSharedManaged(i), ref field2.RefSparseSharedManaged(i), ref field3.RefSparseSharedManaged(i), ref field4.RefSparseSharedManaged(i));
+        }
     }
 
     /// <summary>
@@ -59,15 +217,93 @@ public static void Each<T0, T1, T2, T3, T4>(Iter it, Ecs.EachIterRefCallback<T0,
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4);
+        IterationTechnique flags = it.GetIterationTechnique(5);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4])
-            callback(it, i, ref Managed.GetTypeRef<T0>(pointer0), ref Managed.GetTypeRef<T1>(pointer1), ref Managed.GetTypeRef<T2>(pointer2), ref Managed.GetTypeRef<T3>(pointer3), ref Managed.GetTypeRef<T4>(pointer4));
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, Ecs.EachIterRefCallback<T0, T1, T2, T3, T4> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefUnmanaged(i), ref field1.RefUnmanaged(i), ref field2.RefUnmanaged(i), ref field3.RefUnmanaged(i), ref field4.RefUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, Ecs.EachIterRefCallback<T0, T1, T2, T3, T4> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSharedUnmanaged(i), ref field1.RefSharedUnmanaged(i), ref field2.RefSharedUnmanaged(i), ref field3.RefSharedUnmanaged(i), ref field4.RefSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, Ecs.EachIterRefCallback<T0, T1, T2, T3, T4> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSparseUnmanaged(i), ref field1.RefSparseUnmanaged(i), ref field2.RefSparseUnmanaged(i), ref field3.RefSparseUnmanaged(i), ref field4.RefSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, Ecs.EachIterRefCallback<T0, T1, T2, T3, T4> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSparseSharedUnmanaged(i), ref field1.RefSparseSharedUnmanaged(i), ref field2.RefSparseSharedUnmanaged(i), ref field3.RefSparseSharedUnmanaged(i), ref field4.RefSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, Ecs.EachIterRefCallback<T0, T1, T2, T3, T4> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefManaged(i), ref field1.RefManaged(i), ref field2.RefManaged(i), ref field3.RefManaged(i), ref field4.RefManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, Ecs.EachIterRefCallback<T0, T1, T2, T3, T4> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSharedManaged(i), ref field1.RefSharedManaged(i), ref field2.RefSharedManaged(i), ref field3.RefSharedManaged(i), ref field4.RefSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, Ecs.EachIterRefCallback<T0, T1, T2, T3, T4> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSparseManaged(i), ref field1.RefSparseManaged(i), ref field2.RefSparseManaged(i), ref field3.RefSparseManaged(i), ref field4.RefSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, Ecs.EachIterRefCallback<T0, T1, T2, T3, T4> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSparseSharedManaged(i), ref field1.RefSparseSharedManaged(i), ref field2.RefSparseSharedManaged(i), ref field3.RefSparseSharedManaged(i), ref field4.RefSparseSharedManaged(i));
+        }
     }
 
     /// <summary>
@@ -80,15 +316,93 @@ public static void Each<T0, T1, T2, T3, T4>(Iter it, delegate*<ref T0, ref T1, r
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4);
+        IterationTechnique flags = it.GetIterationTechnique(5);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4])
-            callback(ref Managed.GetTypeRef<T0>(pointer0), ref Managed.GetTypeRef<T1>(pointer1), ref Managed.GetTypeRef<T2>(pointer2), ref Managed.GetTypeRef<T3>(pointer3), ref Managed.GetTypeRef<T4>(pointer4));
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefUnmanaged(i), ref field1.RefUnmanaged(i), ref field2.RefUnmanaged(i), ref field3.RefUnmanaged(i), ref field4.RefUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSharedUnmanaged(i), ref field1.RefSharedUnmanaged(i), ref field2.RefSharedUnmanaged(i), ref field3.RefSharedUnmanaged(i), ref field4.RefSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSparseUnmanaged(i), ref field1.RefSparseUnmanaged(i), ref field2.RefSparseUnmanaged(i), ref field3.RefSparseUnmanaged(i), ref field4.RefSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSparseSharedUnmanaged(i), ref field1.RefSparseSharedUnmanaged(i), ref field2.RefSparseSharedUnmanaged(i), ref field3.RefSparseSharedUnmanaged(i), ref field4.RefSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefManaged(i), ref field1.RefManaged(i), ref field2.RefManaged(i), ref field3.RefManaged(i), ref field4.RefManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSharedManaged(i), ref field1.RefSharedManaged(i), ref field2.RefSharedManaged(i), ref field3.RefSharedManaged(i), ref field4.RefSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSparseManaged(i), ref field1.RefSparseManaged(i), ref field2.RefSparseManaged(i), ref field3.RefSparseManaged(i), ref field4.RefSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSparseSharedManaged(i), ref field1.RefSparseSharedManaged(i), ref field2.RefSparseSharedManaged(i), ref field3.RefSparseSharedManaged(i), ref field4.RefSparseSharedManaged(i));
+        }
     }
 
     /// <summary>
@@ -101,15 +415,93 @@ public static void Each<T0, T1, T2, T3, T4>(Iter it, delegate*<Entity, ref T0, r
     {
         int count = it.Handle->count; Ecs.Assert(it.Handle->count > 0, "No entities returned, use Iter() or Each() without the entity argument instead.");
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4);
+        IterationTechnique flags = it.GetIterationTechnique(5);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4])
-            callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref Managed.GetTypeRef<T0>(pointer0), ref Managed.GetTypeRef<T1>(pointer1), ref Managed.GetTypeRef<T2>(pointer2), ref Managed.GetTypeRef<T3>(pointer3), ref Managed.GetTypeRef<T4>(pointer4));
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefUnmanaged(i), ref field1.RefUnmanaged(i), ref field2.RefUnmanaged(i), ref field3.RefUnmanaged(i), ref field4.RefUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSharedUnmanaged(i), ref field1.RefSharedUnmanaged(i), ref field2.RefSharedUnmanaged(i), ref field3.RefSharedUnmanaged(i), ref field4.RefSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseUnmanaged(i), ref field1.RefSparseUnmanaged(i), ref field2.RefSparseUnmanaged(i), ref field3.RefSparseUnmanaged(i), ref field4.RefSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseSharedUnmanaged(i), ref field1.RefSparseSharedUnmanaged(i), ref field2.RefSparseSharedUnmanaged(i), ref field3.RefSparseSharedUnmanaged(i), ref field4.RefSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefManaged(i), ref field1.RefManaged(i), ref field2.RefManaged(i), ref field3.RefManaged(i), ref field4.RefManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSharedManaged(i), ref field1.RefSharedManaged(i), ref field2.RefSharedManaged(i), ref field3.RefSharedManaged(i), ref field4.RefSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseManaged(i), ref field1.RefSparseManaged(i), ref field2.RefSparseManaged(i), ref field3.RefSparseManaged(i), ref field4.RefSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseSharedManaged(i), ref field1.RefSparseSharedManaged(i), ref field2.RefSparseSharedManaged(i), ref field3.RefSparseSharedManaged(i), ref field4.RefSparseSharedManaged(i));
+        }
     }
 
     /// <summary>
@@ -122,15 +514,93 @@ public static void Each<T0, T1, T2, T3, T4>(Iter it, delegate*<Iter, int, ref T0
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4);
+        IterationTechnique flags = it.GetIterationTechnique(5);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4])
-            callback(it, i, ref Managed.GetTypeRef<T0>(pointer0), ref Managed.GetTypeRef<T1>(pointer1), ref Managed.GetTypeRef<T2>(pointer2), ref Managed.GetTypeRef<T3>(pointer3), ref Managed.GetTypeRef<T4>(pointer4));
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefUnmanaged(i), ref field1.RefUnmanaged(i), ref field2.RefUnmanaged(i), ref field3.RefUnmanaged(i), ref field4.RefUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSharedUnmanaged(i), ref field1.RefSharedUnmanaged(i), ref field2.RefSharedUnmanaged(i), ref field3.RefSharedUnmanaged(i), ref field4.RefSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSparseUnmanaged(i), ref field1.RefSparseUnmanaged(i), ref field2.RefSparseUnmanaged(i), ref field3.RefSparseUnmanaged(i), ref field4.RefSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSparseSharedUnmanaged(i), ref field1.RefSparseSharedUnmanaged(i), ref field2.RefSparseSharedUnmanaged(i), ref field3.RefSparseSharedUnmanaged(i), ref field4.RefSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefManaged(i), ref field1.RefManaged(i), ref field2.RefManaged(i), ref field3.RefManaged(i), ref field4.RefManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSharedManaged(i), ref field1.RefSharedManaged(i), ref field2.RefSharedManaged(i), ref field3.RefSharedManaged(i), ref field4.RefSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSparseManaged(i), ref field1.RefSparseManaged(i), ref field2.RefSparseManaged(i), ref field3.RefSparseManaged(i), ref field4.RefSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSparseSharedManaged(i), ref field1.RefSparseSharedManaged(i), ref field2.RefSparseSharedManaged(i), ref field3.RefSparseSharedManaged(i), ref field4.RefSparseSharedManaged(i));
+        }
     }
 
     /// <summary>
@@ -143,15 +613,93 @@ public static void Each<T0, T1, T2, T3, T4>(Iter it, Ecs.EachPointerCallback<T0,
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4);
+        IterationTechnique flags = it.GetIterationTechnique(5);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4])
-            callback((T0*)pointer0, (T1*)pointer1, (T2*)pointer2, (T3*)pointer3, (T4*)pointer4);
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, Ecs.EachPointerCallback<T0, T1, T2, T3, T4> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerUnmanaged(i), field1.PointerUnmanaged(i), field2.PointerUnmanaged(i), field3.PointerUnmanaged(i), field4.PointerUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, Ecs.EachPointerCallback<T0, T1, T2, T3, T4> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSharedUnmanaged(i), field1.PointerSharedUnmanaged(i), field2.PointerSharedUnmanaged(i), field3.PointerSharedUnmanaged(i), field4.PointerSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, Ecs.EachPointerCallback<T0, T1, T2, T3, T4> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSparseUnmanaged(i), field1.PointerSparseUnmanaged(i), field2.PointerSparseUnmanaged(i), field3.PointerSparseUnmanaged(i), field4.PointerSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, Ecs.EachPointerCallback<T0, T1, T2, T3, T4> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSparseSharedUnmanaged(i), field1.PointerSparseSharedUnmanaged(i), field2.PointerSparseSharedUnmanaged(i), field3.PointerSparseSharedUnmanaged(i), field4.PointerSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, Ecs.EachPointerCallback<T0, T1, T2, T3, T4> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerManaged(i), field1.PointerManaged(i), field2.PointerManaged(i), field3.PointerManaged(i), field4.PointerManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, Ecs.EachPointerCallback<T0, T1, T2, T3, T4> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSharedManaged(i), field1.PointerSharedManaged(i), field2.PointerSharedManaged(i), field3.PointerSharedManaged(i), field4.PointerSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, Ecs.EachPointerCallback<T0, T1, T2, T3, T4> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSparseManaged(i), field1.PointerSparseManaged(i), field2.PointerSparseManaged(i), field3.PointerSparseManaged(i), field4.PointerSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, Ecs.EachPointerCallback<T0, T1, T2, T3, T4> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSparseSharedManaged(i), field1.PointerSparseSharedManaged(i), field2.PointerSparseSharedManaged(i), field3.PointerSparseSharedManaged(i), field4.PointerSparseSharedManaged(i));
+        }
     }
 
     /// <summary>
@@ -164,15 +712,93 @@ public static void Each<T0, T1, T2, T3, T4>(Iter it, Ecs.EachEntityPointerCallba
     {
         int count = it.Handle->count; Ecs.Assert(it.Handle->count > 0, "No entities returned, use Iter() or Each() without the entity argument instead.");
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4);
+        IterationTechnique flags = it.GetIterationTechnique(5);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4])
-            callback(new Entity(it.Handle->world, it.Handle->entities[i]), (T0*)pointer0, (T1*)pointer1, (T2*)pointer2, (T3*)pointer3, (T4*)pointer4);
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerUnmanaged(i), field1.PointerUnmanaged(i), field2.PointerUnmanaged(i), field3.PointerUnmanaged(i), field4.PointerUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSharedUnmanaged(i), field1.PointerSharedUnmanaged(i), field2.PointerSharedUnmanaged(i), field3.PointerSharedUnmanaged(i), field4.PointerSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseUnmanaged(i), field1.PointerSparseUnmanaged(i), field2.PointerSparseUnmanaged(i), field3.PointerSparseUnmanaged(i), field4.PointerSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseSharedUnmanaged(i), field1.PointerSparseSharedUnmanaged(i), field2.PointerSparseSharedUnmanaged(i), field3.PointerSparseSharedUnmanaged(i), field4.PointerSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerManaged(i), field1.PointerManaged(i), field2.PointerManaged(i), field3.PointerManaged(i), field4.PointerManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSharedManaged(i), field1.PointerSharedManaged(i), field2.PointerSharedManaged(i), field3.PointerSharedManaged(i), field4.PointerSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseManaged(i), field1.PointerSparseManaged(i), field2.PointerSparseManaged(i), field3.PointerSparseManaged(i), field4.PointerSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseSharedManaged(i), field1.PointerSparseSharedManaged(i), field2.PointerSparseSharedManaged(i), field3.PointerSparseSharedManaged(i), field4.PointerSparseSharedManaged(i));
+        }
     }
 
     /// <summary>
@@ -185,15 +811,93 @@ public static void Each<T0, T1, T2, T3, T4>(Iter it, Ecs.EachIterPointerCallback
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4);
+        IterationTechnique flags = it.GetIterationTechnique(5);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4])
-            callback(it, i, (T0*)pointer0, (T1*)pointer1, (T2*)pointer2, (T3*)pointer3, (T4*)pointer4);
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerUnmanaged(i), field1.PointerUnmanaged(i), field2.PointerUnmanaged(i), field3.PointerUnmanaged(i), field4.PointerUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSharedUnmanaged(i), field1.PointerSharedUnmanaged(i), field2.PointerSharedUnmanaged(i), field3.PointerSharedUnmanaged(i), field4.PointerSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSparseUnmanaged(i), field1.PointerSparseUnmanaged(i), field2.PointerSparseUnmanaged(i), field3.PointerSparseUnmanaged(i), field4.PointerSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSparseSharedUnmanaged(i), field1.PointerSparseSharedUnmanaged(i), field2.PointerSparseSharedUnmanaged(i), field3.PointerSparseSharedUnmanaged(i), field4.PointerSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerManaged(i), field1.PointerManaged(i), field2.PointerManaged(i), field3.PointerManaged(i), field4.PointerManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSharedManaged(i), field1.PointerSharedManaged(i), field2.PointerSharedManaged(i), field3.PointerSharedManaged(i), field4.PointerSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSparseManaged(i), field1.PointerSparseManaged(i), field2.PointerSparseManaged(i), field3.PointerSparseManaged(i), field4.PointerSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSparseSharedManaged(i), field1.PointerSparseSharedManaged(i), field2.PointerSparseSharedManaged(i), field3.PointerSparseSharedManaged(i), field4.PointerSparseSharedManaged(i));
+        }
     }
 
     /// <summary>
@@ -206,15 +910,93 @@ public static void Each<T0, T1, T2, T3, T4>(Iter it, delegate*<T0*, T1*, T2*, T3
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4);
+        IterationTechnique flags = it.GetIterationTechnique(5);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4])
-            callback((T0*)pointer0, (T1*)pointer1, (T2*)pointer2, (T3*)pointer3, (T4*)pointer4);
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerUnmanaged(i), field1.PointerUnmanaged(i), field2.PointerUnmanaged(i), field3.PointerUnmanaged(i), field4.PointerUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSharedUnmanaged(i), field1.PointerSharedUnmanaged(i), field2.PointerSharedUnmanaged(i), field3.PointerSharedUnmanaged(i), field4.PointerSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSparseUnmanaged(i), field1.PointerSparseUnmanaged(i), field2.PointerSparseUnmanaged(i), field3.PointerSparseUnmanaged(i), field4.PointerSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSparseSharedUnmanaged(i), field1.PointerSparseSharedUnmanaged(i), field2.PointerSparseSharedUnmanaged(i), field3.PointerSparseSharedUnmanaged(i), field4.PointerSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerManaged(i), field1.PointerManaged(i), field2.PointerManaged(i), field3.PointerManaged(i), field4.PointerManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSharedManaged(i), field1.PointerSharedManaged(i), field2.PointerSharedManaged(i), field3.PointerSharedManaged(i), field4.PointerSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSparseManaged(i), field1.PointerSparseManaged(i), field2.PointerSparseManaged(i), field3.PointerSparseManaged(i), field4.PointerSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSparseSharedManaged(i), field1.PointerSparseSharedManaged(i), field2.PointerSparseSharedManaged(i), field3.PointerSparseSharedManaged(i), field4.PointerSparseSharedManaged(i));
+        }
     }
 
     /// <summary>
@@ -227,15 +1009,93 @@ public static void Each<T0, T1, T2, T3, T4>(Iter it, delegate*<Entity, T0*, T1*,
     {
         int count = it.Handle->count; Ecs.Assert(it.Handle->count > 0, "No entities returned, use Iter() or Each() without the entity argument instead.");
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4);
+        IterationTechnique flags = it.GetIterationTechnique(5);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4])
-            callback(new Entity(it.Handle->world, it.Handle->entities[i]), (T0*)pointer0, (T1*)pointer1, (T2*)pointer2, (T3*)pointer3, (T4*)pointer4);
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerUnmanaged(i), field1.PointerUnmanaged(i), field2.PointerUnmanaged(i), field3.PointerUnmanaged(i), field4.PointerUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSharedUnmanaged(i), field1.PointerSharedUnmanaged(i), field2.PointerSharedUnmanaged(i), field3.PointerSharedUnmanaged(i), field4.PointerSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseUnmanaged(i), field1.PointerSparseUnmanaged(i), field2.PointerSparseUnmanaged(i), field3.PointerSparseUnmanaged(i), field4.PointerSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseSharedUnmanaged(i), field1.PointerSparseSharedUnmanaged(i), field2.PointerSparseSharedUnmanaged(i), field3.PointerSparseSharedUnmanaged(i), field4.PointerSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerManaged(i), field1.PointerManaged(i), field2.PointerManaged(i), field3.PointerManaged(i), field4.PointerManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSharedManaged(i), field1.PointerSharedManaged(i), field2.PointerSharedManaged(i), field3.PointerSharedManaged(i), field4.PointerSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseManaged(i), field1.PointerSparseManaged(i), field2.PointerSparseManaged(i), field3.PointerSparseManaged(i), field4.PointerSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseSharedManaged(i), field1.PointerSparseSharedManaged(i), field2.PointerSparseSharedManaged(i), field3.PointerSparseSharedManaged(i), field4.PointerSparseSharedManaged(i));
+        }
     }
 
     /// <summary>
@@ -248,14 +1108,92 @@ public static void Each<T0, T1, T2, T3, T4>(Iter it, delegate*<Iter, int, T0*, T
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4);
+        IterationTechnique flags = it.GetIterationTechnique(5);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4])
-            callback(it, i, (T0*)pointer0, (T1*)pointer1, (T2*)pointer2, (T3*)pointer3, (T4*)pointer4);
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerUnmanaged(i), field1.PointerUnmanaged(i), field2.PointerUnmanaged(i), field3.PointerUnmanaged(i), field4.PointerUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSharedUnmanaged(i), field1.PointerSharedUnmanaged(i), field2.PointerSharedUnmanaged(i), field3.PointerSharedUnmanaged(i), field4.PointerSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSparseUnmanaged(i), field1.PointerSparseUnmanaged(i), field2.PointerSparseUnmanaged(i), field3.PointerSparseUnmanaged(i), field4.PointerSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSparseSharedUnmanaged(i), field1.PointerSparseSharedUnmanaged(i), field2.PointerSparseSharedUnmanaged(i), field3.PointerSparseSharedUnmanaged(i), field4.PointerSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerManaged(i), field1.PointerManaged(i), field2.PointerManaged(i), field3.PointerManaged(i), field4.PointerManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSharedManaged(i), field1.PointerSharedManaged(i), field2.PointerSharedManaged(i), field3.PointerSharedManaged(i), field4.PointerSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSparseManaged(i), field1.PointerSparseManaged(i), field2.PointerSparseManaged(i), field3.PointerSparseManaged(i), field4.PointerSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSparseSharedManaged(i), field1.PointerSparseSharedManaged(i), field2.PointerSparseSharedManaged(i), field3.PointerSparseSharedManaged(i), field4.PointerSparseSharedManaged(i));
+        }
     }
 }
\ No newline at end of file
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/Invoker/Each/Iterator/T6.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/Invoker/Each/Iterator/T6.g.cs
index a7c357b6..02adc970 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/Invoker/Each/Iterator/T6.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/Invoker/Each/Iterator/T6.g.cs
@@ -1,5 +1,7 @@
 // Each/Iterator/T6.g.cs
 // File was auto-generated by /_/src/Flecs.NET.Codegen/Generators/Invoker.cs
+using System;
+using System.Runtime.CompilerServices;
 using Flecs.NET.Utilities;
 using static Flecs.NET.Bindings.flecs;
 
@@ -17,15 +19,93 @@ public static void Each<T0, T1, T2, T3, T4, T5>(Iter it, Ecs.EachRefCallback<T0,
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5);
+        IterationTechnique flags = it.GetIterationTechnique(6);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5])
-            callback(ref Managed.GetTypeRef<T0>(pointer0), ref Managed.GetTypeRef<T1>(pointer1), ref Managed.GetTypeRef<T2>(pointer2), ref Managed.GetTypeRef<T3>(pointer3), ref Managed.GetTypeRef<T4>(pointer4), ref Managed.GetTypeRef<T5>(pointer5));
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefUnmanaged(i), ref field1.RefUnmanaged(i), ref field2.RefUnmanaged(i), ref field3.RefUnmanaged(i), ref field4.RefUnmanaged(i), ref field5.RefUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSharedUnmanaged(i), ref field1.RefSharedUnmanaged(i), ref field2.RefSharedUnmanaged(i), ref field3.RefSharedUnmanaged(i), ref field4.RefSharedUnmanaged(i), ref field5.RefSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSparseUnmanaged(i), ref field1.RefSparseUnmanaged(i), ref field2.RefSparseUnmanaged(i), ref field3.RefSparseUnmanaged(i), ref field4.RefSparseUnmanaged(i), ref field5.RefSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSparseSharedUnmanaged(i), ref field1.RefSparseSharedUnmanaged(i), ref field2.RefSparseSharedUnmanaged(i), ref field3.RefSparseSharedUnmanaged(i), ref field4.RefSparseSharedUnmanaged(i), ref field5.RefSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefManaged(i), ref field1.RefManaged(i), ref field2.RefManaged(i), ref field3.RefManaged(i), ref field4.RefManaged(i), ref field5.RefManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSharedManaged(i), ref field1.RefSharedManaged(i), ref field2.RefSharedManaged(i), ref field3.RefSharedManaged(i), ref field4.RefSharedManaged(i), ref field5.RefSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSparseManaged(i), ref field1.RefSparseManaged(i), ref field2.RefSparseManaged(i), ref field3.RefSparseManaged(i), ref field4.RefSparseManaged(i), ref field5.RefSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSparseSharedManaged(i), ref field1.RefSparseSharedManaged(i), ref field2.RefSparseSharedManaged(i), ref field3.RefSparseSharedManaged(i), ref field4.RefSparseSharedManaged(i), ref field5.RefSparseSharedManaged(i));
+        }
     }
 
     /// <summary>
@@ -38,15 +118,93 @@ public static void Each<T0, T1, T2, T3, T4, T5>(Iter it, Ecs.EachEntityRefCallba
     {
         int count = it.Handle->count; Ecs.Assert(it.Handle->count > 0, "No entities returned, use Iter() or Each() without the entity argument instead.");
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5);
+        IterationTechnique flags = it.GetIterationTechnique(6);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5])
-            callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref Managed.GetTypeRef<T0>(pointer0), ref Managed.GetTypeRef<T1>(pointer1), ref Managed.GetTypeRef<T2>(pointer2), ref Managed.GetTypeRef<T3>(pointer3), ref Managed.GetTypeRef<T4>(pointer4), ref Managed.GetTypeRef<T5>(pointer5));
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefUnmanaged(i), ref field1.RefUnmanaged(i), ref field2.RefUnmanaged(i), ref field3.RefUnmanaged(i), ref field4.RefUnmanaged(i), ref field5.RefUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSharedUnmanaged(i), ref field1.RefSharedUnmanaged(i), ref field2.RefSharedUnmanaged(i), ref field3.RefSharedUnmanaged(i), ref field4.RefSharedUnmanaged(i), ref field5.RefSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseUnmanaged(i), ref field1.RefSparseUnmanaged(i), ref field2.RefSparseUnmanaged(i), ref field3.RefSparseUnmanaged(i), ref field4.RefSparseUnmanaged(i), ref field5.RefSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseSharedUnmanaged(i), ref field1.RefSparseSharedUnmanaged(i), ref field2.RefSparseSharedUnmanaged(i), ref field3.RefSparseSharedUnmanaged(i), ref field4.RefSparseSharedUnmanaged(i), ref field5.RefSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefManaged(i), ref field1.RefManaged(i), ref field2.RefManaged(i), ref field3.RefManaged(i), ref field4.RefManaged(i), ref field5.RefManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSharedManaged(i), ref field1.RefSharedManaged(i), ref field2.RefSharedManaged(i), ref field3.RefSharedManaged(i), ref field4.RefSharedManaged(i), ref field5.RefSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseManaged(i), ref field1.RefSparseManaged(i), ref field2.RefSparseManaged(i), ref field3.RefSparseManaged(i), ref field4.RefSparseManaged(i), ref field5.RefSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseSharedManaged(i), ref field1.RefSparseSharedManaged(i), ref field2.RefSparseSharedManaged(i), ref field3.RefSparseSharedManaged(i), ref field4.RefSparseSharedManaged(i), ref field5.RefSparseSharedManaged(i));
+        }
     }
 
     /// <summary>
@@ -59,15 +217,93 @@ public static void Each<T0, T1, T2, T3, T4, T5>(Iter it, Ecs.EachIterRefCallback
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5);
+        IterationTechnique flags = it.GetIterationTechnique(6);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5])
-            callback(it, i, ref Managed.GetTypeRef<T0>(pointer0), ref Managed.GetTypeRef<T1>(pointer1), ref Managed.GetTypeRef<T2>(pointer2), ref Managed.GetTypeRef<T3>(pointer3), ref Managed.GetTypeRef<T4>(pointer4), ref Managed.GetTypeRef<T5>(pointer5));
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefUnmanaged(i), ref field1.RefUnmanaged(i), ref field2.RefUnmanaged(i), ref field3.RefUnmanaged(i), ref field4.RefUnmanaged(i), ref field5.RefUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSharedUnmanaged(i), ref field1.RefSharedUnmanaged(i), ref field2.RefSharedUnmanaged(i), ref field3.RefSharedUnmanaged(i), ref field4.RefSharedUnmanaged(i), ref field5.RefSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSparseUnmanaged(i), ref field1.RefSparseUnmanaged(i), ref field2.RefSparseUnmanaged(i), ref field3.RefSparseUnmanaged(i), ref field4.RefSparseUnmanaged(i), ref field5.RefSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSparseSharedUnmanaged(i), ref field1.RefSparseSharedUnmanaged(i), ref field2.RefSparseSharedUnmanaged(i), ref field3.RefSparseSharedUnmanaged(i), ref field4.RefSparseSharedUnmanaged(i), ref field5.RefSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefManaged(i), ref field1.RefManaged(i), ref field2.RefManaged(i), ref field3.RefManaged(i), ref field4.RefManaged(i), ref field5.RefManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSharedManaged(i), ref field1.RefSharedManaged(i), ref field2.RefSharedManaged(i), ref field3.RefSharedManaged(i), ref field4.RefSharedManaged(i), ref field5.RefSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSparseManaged(i), ref field1.RefSparseManaged(i), ref field2.RefSparseManaged(i), ref field3.RefSparseManaged(i), ref field4.RefSparseManaged(i), ref field5.RefSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSparseSharedManaged(i), ref field1.RefSparseSharedManaged(i), ref field2.RefSparseSharedManaged(i), ref field3.RefSparseSharedManaged(i), ref field4.RefSparseSharedManaged(i), ref field5.RefSparseSharedManaged(i));
+        }
     }
 
     /// <summary>
@@ -80,15 +316,93 @@ public static void Each<T0, T1, T2, T3, T4, T5>(Iter it, delegate*<ref T0, ref T
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5);
+        IterationTechnique flags = it.GetIterationTechnique(6);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5])
-            callback(ref Managed.GetTypeRef<T0>(pointer0), ref Managed.GetTypeRef<T1>(pointer1), ref Managed.GetTypeRef<T2>(pointer2), ref Managed.GetTypeRef<T3>(pointer3), ref Managed.GetTypeRef<T4>(pointer4), ref Managed.GetTypeRef<T5>(pointer5));
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefUnmanaged(i), ref field1.RefUnmanaged(i), ref field2.RefUnmanaged(i), ref field3.RefUnmanaged(i), ref field4.RefUnmanaged(i), ref field5.RefUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSharedUnmanaged(i), ref field1.RefSharedUnmanaged(i), ref field2.RefSharedUnmanaged(i), ref field3.RefSharedUnmanaged(i), ref field4.RefSharedUnmanaged(i), ref field5.RefSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSparseUnmanaged(i), ref field1.RefSparseUnmanaged(i), ref field2.RefSparseUnmanaged(i), ref field3.RefSparseUnmanaged(i), ref field4.RefSparseUnmanaged(i), ref field5.RefSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSparseSharedUnmanaged(i), ref field1.RefSparseSharedUnmanaged(i), ref field2.RefSparseSharedUnmanaged(i), ref field3.RefSparseSharedUnmanaged(i), ref field4.RefSparseSharedUnmanaged(i), ref field5.RefSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefManaged(i), ref field1.RefManaged(i), ref field2.RefManaged(i), ref field3.RefManaged(i), ref field4.RefManaged(i), ref field5.RefManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSharedManaged(i), ref field1.RefSharedManaged(i), ref field2.RefSharedManaged(i), ref field3.RefSharedManaged(i), ref field4.RefSharedManaged(i), ref field5.RefSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSparseManaged(i), ref field1.RefSparseManaged(i), ref field2.RefSparseManaged(i), ref field3.RefSparseManaged(i), ref field4.RefSparseManaged(i), ref field5.RefSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSparseSharedManaged(i), ref field1.RefSparseSharedManaged(i), ref field2.RefSparseSharedManaged(i), ref field3.RefSparseSharedManaged(i), ref field4.RefSparseSharedManaged(i), ref field5.RefSparseSharedManaged(i));
+        }
     }
 
     /// <summary>
@@ -101,15 +415,93 @@ public static void Each<T0, T1, T2, T3, T4, T5>(Iter it, delegate*<Entity, ref T
     {
         int count = it.Handle->count; Ecs.Assert(it.Handle->count > 0, "No entities returned, use Iter() or Each() without the entity argument instead.");
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5);
+        IterationTechnique flags = it.GetIterationTechnique(6);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5])
-            callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref Managed.GetTypeRef<T0>(pointer0), ref Managed.GetTypeRef<T1>(pointer1), ref Managed.GetTypeRef<T2>(pointer2), ref Managed.GetTypeRef<T3>(pointer3), ref Managed.GetTypeRef<T4>(pointer4), ref Managed.GetTypeRef<T5>(pointer5));
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefUnmanaged(i), ref field1.RefUnmanaged(i), ref field2.RefUnmanaged(i), ref field3.RefUnmanaged(i), ref field4.RefUnmanaged(i), ref field5.RefUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSharedUnmanaged(i), ref field1.RefSharedUnmanaged(i), ref field2.RefSharedUnmanaged(i), ref field3.RefSharedUnmanaged(i), ref field4.RefSharedUnmanaged(i), ref field5.RefSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseUnmanaged(i), ref field1.RefSparseUnmanaged(i), ref field2.RefSparseUnmanaged(i), ref field3.RefSparseUnmanaged(i), ref field4.RefSparseUnmanaged(i), ref field5.RefSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseSharedUnmanaged(i), ref field1.RefSparseSharedUnmanaged(i), ref field2.RefSparseSharedUnmanaged(i), ref field3.RefSparseSharedUnmanaged(i), ref field4.RefSparseSharedUnmanaged(i), ref field5.RefSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefManaged(i), ref field1.RefManaged(i), ref field2.RefManaged(i), ref field3.RefManaged(i), ref field4.RefManaged(i), ref field5.RefManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSharedManaged(i), ref field1.RefSharedManaged(i), ref field2.RefSharedManaged(i), ref field3.RefSharedManaged(i), ref field4.RefSharedManaged(i), ref field5.RefSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseManaged(i), ref field1.RefSparseManaged(i), ref field2.RefSparseManaged(i), ref field3.RefSparseManaged(i), ref field4.RefSparseManaged(i), ref field5.RefSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseSharedManaged(i), ref field1.RefSparseSharedManaged(i), ref field2.RefSparseSharedManaged(i), ref field3.RefSparseSharedManaged(i), ref field4.RefSparseSharedManaged(i), ref field5.RefSparseSharedManaged(i));
+        }
     }
 
     /// <summary>
@@ -122,15 +514,93 @@ public static void Each<T0, T1, T2, T3, T4, T5>(Iter it, delegate*<Iter, int, re
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5);
+        IterationTechnique flags = it.GetIterationTechnique(6);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5])
-            callback(it, i, ref Managed.GetTypeRef<T0>(pointer0), ref Managed.GetTypeRef<T1>(pointer1), ref Managed.GetTypeRef<T2>(pointer2), ref Managed.GetTypeRef<T3>(pointer3), ref Managed.GetTypeRef<T4>(pointer4), ref Managed.GetTypeRef<T5>(pointer5));
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefUnmanaged(i), ref field1.RefUnmanaged(i), ref field2.RefUnmanaged(i), ref field3.RefUnmanaged(i), ref field4.RefUnmanaged(i), ref field5.RefUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSharedUnmanaged(i), ref field1.RefSharedUnmanaged(i), ref field2.RefSharedUnmanaged(i), ref field3.RefSharedUnmanaged(i), ref field4.RefSharedUnmanaged(i), ref field5.RefSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSparseUnmanaged(i), ref field1.RefSparseUnmanaged(i), ref field2.RefSparseUnmanaged(i), ref field3.RefSparseUnmanaged(i), ref field4.RefSparseUnmanaged(i), ref field5.RefSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSparseSharedUnmanaged(i), ref field1.RefSparseSharedUnmanaged(i), ref field2.RefSparseSharedUnmanaged(i), ref field3.RefSparseSharedUnmanaged(i), ref field4.RefSparseSharedUnmanaged(i), ref field5.RefSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefManaged(i), ref field1.RefManaged(i), ref field2.RefManaged(i), ref field3.RefManaged(i), ref field4.RefManaged(i), ref field5.RefManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSharedManaged(i), ref field1.RefSharedManaged(i), ref field2.RefSharedManaged(i), ref field3.RefSharedManaged(i), ref field4.RefSharedManaged(i), ref field5.RefSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSparseManaged(i), ref field1.RefSparseManaged(i), ref field2.RefSparseManaged(i), ref field3.RefSparseManaged(i), ref field4.RefSparseManaged(i), ref field5.RefSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSparseSharedManaged(i), ref field1.RefSparseSharedManaged(i), ref field2.RefSparseSharedManaged(i), ref field3.RefSparseSharedManaged(i), ref field4.RefSparseSharedManaged(i), ref field5.RefSparseSharedManaged(i));
+        }
     }
 
     /// <summary>
@@ -143,15 +613,93 @@ public static void Each<T0, T1, T2, T3, T4, T5>(Iter it, Ecs.EachPointerCallback
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5);
+        IterationTechnique flags = it.GetIterationTechnique(6);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5])
-            callback((T0*)pointer0, (T1*)pointer1, (T2*)pointer2, (T3*)pointer3, (T4*)pointer4, (T5*)pointer5);
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerUnmanaged(i), field1.PointerUnmanaged(i), field2.PointerUnmanaged(i), field3.PointerUnmanaged(i), field4.PointerUnmanaged(i), field5.PointerUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSharedUnmanaged(i), field1.PointerSharedUnmanaged(i), field2.PointerSharedUnmanaged(i), field3.PointerSharedUnmanaged(i), field4.PointerSharedUnmanaged(i), field5.PointerSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSparseUnmanaged(i), field1.PointerSparseUnmanaged(i), field2.PointerSparseUnmanaged(i), field3.PointerSparseUnmanaged(i), field4.PointerSparseUnmanaged(i), field5.PointerSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSparseSharedUnmanaged(i), field1.PointerSparseSharedUnmanaged(i), field2.PointerSparseSharedUnmanaged(i), field3.PointerSparseSharedUnmanaged(i), field4.PointerSparseSharedUnmanaged(i), field5.PointerSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerManaged(i), field1.PointerManaged(i), field2.PointerManaged(i), field3.PointerManaged(i), field4.PointerManaged(i), field5.PointerManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSharedManaged(i), field1.PointerSharedManaged(i), field2.PointerSharedManaged(i), field3.PointerSharedManaged(i), field4.PointerSharedManaged(i), field5.PointerSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSparseManaged(i), field1.PointerSparseManaged(i), field2.PointerSparseManaged(i), field3.PointerSparseManaged(i), field4.PointerSparseManaged(i), field5.PointerSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSparseSharedManaged(i), field1.PointerSparseSharedManaged(i), field2.PointerSparseSharedManaged(i), field3.PointerSparseSharedManaged(i), field4.PointerSparseSharedManaged(i), field5.PointerSparseSharedManaged(i));
+        }
     }
 
     /// <summary>
@@ -164,15 +712,93 @@ public static void Each<T0, T1, T2, T3, T4, T5>(Iter it, Ecs.EachEntityPointerCa
     {
         int count = it.Handle->count; Ecs.Assert(it.Handle->count > 0, "No entities returned, use Iter() or Each() without the entity argument instead.");
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5);
+        IterationTechnique flags = it.GetIterationTechnique(6);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5])
-            callback(new Entity(it.Handle->world, it.Handle->entities[i]), (T0*)pointer0, (T1*)pointer1, (T2*)pointer2, (T3*)pointer3, (T4*)pointer4, (T5*)pointer5);
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerUnmanaged(i), field1.PointerUnmanaged(i), field2.PointerUnmanaged(i), field3.PointerUnmanaged(i), field4.PointerUnmanaged(i), field5.PointerUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSharedUnmanaged(i), field1.PointerSharedUnmanaged(i), field2.PointerSharedUnmanaged(i), field3.PointerSharedUnmanaged(i), field4.PointerSharedUnmanaged(i), field5.PointerSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseUnmanaged(i), field1.PointerSparseUnmanaged(i), field2.PointerSparseUnmanaged(i), field3.PointerSparseUnmanaged(i), field4.PointerSparseUnmanaged(i), field5.PointerSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseSharedUnmanaged(i), field1.PointerSparseSharedUnmanaged(i), field2.PointerSparseSharedUnmanaged(i), field3.PointerSparseSharedUnmanaged(i), field4.PointerSparseSharedUnmanaged(i), field5.PointerSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerManaged(i), field1.PointerManaged(i), field2.PointerManaged(i), field3.PointerManaged(i), field4.PointerManaged(i), field5.PointerManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSharedManaged(i), field1.PointerSharedManaged(i), field2.PointerSharedManaged(i), field3.PointerSharedManaged(i), field4.PointerSharedManaged(i), field5.PointerSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseManaged(i), field1.PointerSparseManaged(i), field2.PointerSparseManaged(i), field3.PointerSparseManaged(i), field4.PointerSparseManaged(i), field5.PointerSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseSharedManaged(i), field1.PointerSparseSharedManaged(i), field2.PointerSparseSharedManaged(i), field3.PointerSparseSharedManaged(i), field4.PointerSparseSharedManaged(i), field5.PointerSparseSharedManaged(i));
+        }
     }
 
     /// <summary>
@@ -185,15 +811,93 @@ public static void Each<T0, T1, T2, T3, T4, T5>(Iter it, Ecs.EachIterPointerCall
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5);
+        IterationTechnique flags = it.GetIterationTechnique(6);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5])
-            callback(it, i, (T0*)pointer0, (T1*)pointer1, (T2*)pointer2, (T3*)pointer3, (T4*)pointer4, (T5*)pointer5);
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerUnmanaged(i), field1.PointerUnmanaged(i), field2.PointerUnmanaged(i), field3.PointerUnmanaged(i), field4.PointerUnmanaged(i), field5.PointerUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSharedUnmanaged(i), field1.PointerSharedUnmanaged(i), field2.PointerSharedUnmanaged(i), field3.PointerSharedUnmanaged(i), field4.PointerSharedUnmanaged(i), field5.PointerSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSparseUnmanaged(i), field1.PointerSparseUnmanaged(i), field2.PointerSparseUnmanaged(i), field3.PointerSparseUnmanaged(i), field4.PointerSparseUnmanaged(i), field5.PointerSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSparseSharedUnmanaged(i), field1.PointerSparseSharedUnmanaged(i), field2.PointerSparseSharedUnmanaged(i), field3.PointerSparseSharedUnmanaged(i), field4.PointerSparseSharedUnmanaged(i), field5.PointerSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerManaged(i), field1.PointerManaged(i), field2.PointerManaged(i), field3.PointerManaged(i), field4.PointerManaged(i), field5.PointerManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSharedManaged(i), field1.PointerSharedManaged(i), field2.PointerSharedManaged(i), field3.PointerSharedManaged(i), field4.PointerSharedManaged(i), field5.PointerSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSparseManaged(i), field1.PointerSparseManaged(i), field2.PointerSparseManaged(i), field3.PointerSparseManaged(i), field4.PointerSparseManaged(i), field5.PointerSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSparseSharedManaged(i), field1.PointerSparseSharedManaged(i), field2.PointerSparseSharedManaged(i), field3.PointerSparseSharedManaged(i), field4.PointerSparseSharedManaged(i), field5.PointerSparseSharedManaged(i));
+        }
     }
 
     /// <summary>
@@ -206,15 +910,93 @@ public static void Each<T0, T1, T2, T3, T4, T5>(Iter it, delegate*<T0*, T1*, T2*
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5);
+        IterationTechnique flags = it.GetIterationTechnique(6);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5])
-            callback((T0*)pointer0, (T1*)pointer1, (T2*)pointer2, (T3*)pointer3, (T4*)pointer4, (T5*)pointer5);
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, T5*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerUnmanaged(i), field1.PointerUnmanaged(i), field2.PointerUnmanaged(i), field3.PointerUnmanaged(i), field4.PointerUnmanaged(i), field5.PointerUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, T5*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSharedUnmanaged(i), field1.PointerSharedUnmanaged(i), field2.PointerSharedUnmanaged(i), field3.PointerSharedUnmanaged(i), field4.PointerSharedUnmanaged(i), field5.PointerSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, T5*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSparseUnmanaged(i), field1.PointerSparseUnmanaged(i), field2.PointerSparseUnmanaged(i), field3.PointerSparseUnmanaged(i), field4.PointerSparseUnmanaged(i), field5.PointerSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, T5*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSparseSharedUnmanaged(i), field1.PointerSparseSharedUnmanaged(i), field2.PointerSparseSharedUnmanaged(i), field3.PointerSparseSharedUnmanaged(i), field4.PointerSparseSharedUnmanaged(i), field5.PointerSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, T5*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerManaged(i), field1.PointerManaged(i), field2.PointerManaged(i), field3.PointerManaged(i), field4.PointerManaged(i), field5.PointerManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, T5*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSharedManaged(i), field1.PointerSharedManaged(i), field2.PointerSharedManaged(i), field3.PointerSharedManaged(i), field4.PointerSharedManaged(i), field5.PointerSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, T5*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSparseManaged(i), field1.PointerSparseManaged(i), field2.PointerSparseManaged(i), field3.PointerSparseManaged(i), field4.PointerSparseManaged(i), field5.PointerSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, T5*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSparseSharedManaged(i), field1.PointerSparseSharedManaged(i), field2.PointerSparseSharedManaged(i), field3.PointerSparseSharedManaged(i), field4.PointerSparseSharedManaged(i), field5.PointerSparseSharedManaged(i));
+        }
     }
 
     /// <summary>
@@ -227,15 +1009,93 @@ public static void Each<T0, T1, T2, T3, T4, T5>(Iter it, delegate*<Entity, T0*,
     {
         int count = it.Handle->count; Ecs.Assert(it.Handle->count > 0, "No entities returned, use Iter() or Each() without the entity argument instead.");
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5);
+        IterationTechnique flags = it.GetIterationTechnique(6);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5])
-            callback(new Entity(it.Handle->world, it.Handle->entities[i]), (T0*)pointer0, (T1*)pointer1, (T2*)pointer2, (T3*)pointer3, (T4*)pointer4, (T5*)pointer5);
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerUnmanaged(i), field1.PointerUnmanaged(i), field2.PointerUnmanaged(i), field3.PointerUnmanaged(i), field4.PointerUnmanaged(i), field5.PointerUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSharedUnmanaged(i), field1.PointerSharedUnmanaged(i), field2.PointerSharedUnmanaged(i), field3.PointerSharedUnmanaged(i), field4.PointerSharedUnmanaged(i), field5.PointerSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseUnmanaged(i), field1.PointerSparseUnmanaged(i), field2.PointerSparseUnmanaged(i), field3.PointerSparseUnmanaged(i), field4.PointerSparseUnmanaged(i), field5.PointerSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseSharedUnmanaged(i), field1.PointerSparseSharedUnmanaged(i), field2.PointerSparseSharedUnmanaged(i), field3.PointerSparseSharedUnmanaged(i), field4.PointerSparseSharedUnmanaged(i), field5.PointerSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerManaged(i), field1.PointerManaged(i), field2.PointerManaged(i), field3.PointerManaged(i), field4.PointerManaged(i), field5.PointerManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSharedManaged(i), field1.PointerSharedManaged(i), field2.PointerSharedManaged(i), field3.PointerSharedManaged(i), field4.PointerSharedManaged(i), field5.PointerSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseManaged(i), field1.PointerSparseManaged(i), field2.PointerSparseManaged(i), field3.PointerSparseManaged(i), field4.PointerSparseManaged(i), field5.PointerSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseSharedManaged(i), field1.PointerSparseSharedManaged(i), field2.PointerSparseSharedManaged(i), field3.PointerSparseSharedManaged(i), field4.PointerSparseSharedManaged(i), field5.PointerSparseSharedManaged(i));
+        }
     }
 
     /// <summary>
@@ -248,14 +1108,92 @@ public static void Each<T0, T1, T2, T3, T4, T5>(Iter it, delegate*<Iter, int, T0
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5);
+        IterationTechnique flags = it.GetIterationTechnique(6);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5])
-            callback(it, i, (T0*)pointer0, (T1*)pointer1, (T2*)pointer2, (T3*)pointer3, (T4*)pointer4, (T5*)pointer5);
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerUnmanaged(i), field1.PointerUnmanaged(i), field2.PointerUnmanaged(i), field3.PointerUnmanaged(i), field4.PointerUnmanaged(i), field5.PointerUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSharedUnmanaged(i), field1.PointerSharedUnmanaged(i), field2.PointerSharedUnmanaged(i), field3.PointerSharedUnmanaged(i), field4.PointerSharedUnmanaged(i), field5.PointerSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSparseUnmanaged(i), field1.PointerSparseUnmanaged(i), field2.PointerSparseUnmanaged(i), field3.PointerSparseUnmanaged(i), field4.PointerSparseUnmanaged(i), field5.PointerSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSparseSharedUnmanaged(i), field1.PointerSparseSharedUnmanaged(i), field2.PointerSparseSharedUnmanaged(i), field3.PointerSparseSharedUnmanaged(i), field4.PointerSparseSharedUnmanaged(i), field5.PointerSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerManaged(i), field1.PointerManaged(i), field2.PointerManaged(i), field3.PointerManaged(i), field4.PointerManaged(i), field5.PointerManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSharedManaged(i), field1.PointerSharedManaged(i), field2.PointerSharedManaged(i), field3.PointerSharedManaged(i), field4.PointerSharedManaged(i), field5.PointerSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSparseManaged(i), field1.PointerSparseManaged(i), field2.PointerSparseManaged(i), field3.PointerSparseManaged(i), field4.PointerSparseManaged(i), field5.PointerSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSparseSharedManaged(i), field1.PointerSparseSharedManaged(i), field2.PointerSparseSharedManaged(i), field3.PointerSparseSharedManaged(i), field4.PointerSparseSharedManaged(i), field5.PointerSparseSharedManaged(i));
+        }
     }
 }
\ No newline at end of file
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/Invoker/Each/Iterator/T7.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/Invoker/Each/Iterator/T7.g.cs
index 186000ea..230e1060 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/Invoker/Each/Iterator/T7.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/Invoker/Each/Iterator/T7.g.cs
@@ -1,5 +1,7 @@
 // Each/Iterator/T7.g.cs
 // File was auto-generated by /_/src/Flecs.NET.Codegen/Generators/Invoker.cs
+using System;
+using System.Runtime.CompilerServices;
 using Flecs.NET.Utilities;
 using static Flecs.NET.Bindings.flecs;
 
@@ -17,15 +19,93 @@ public static void Each<T0, T1, T2, T3, T4, T5, T6>(Iter it, Ecs.EachRefCallback
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6);
+        IterationTechnique flags = it.GetIterationTechnique(7);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6])
-            callback(ref Managed.GetTypeRef<T0>(pointer0), ref Managed.GetTypeRef<T1>(pointer1), ref Managed.GetTypeRef<T2>(pointer2), ref Managed.GetTypeRef<T3>(pointer3), ref Managed.GetTypeRef<T4>(pointer4), ref Managed.GetTypeRef<T5>(pointer5), ref Managed.GetTypeRef<T6>(pointer6));
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5, T6> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefUnmanaged(i), ref field1.RefUnmanaged(i), ref field2.RefUnmanaged(i), ref field3.RefUnmanaged(i), ref field4.RefUnmanaged(i), ref field5.RefUnmanaged(i), ref field6.RefUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5, T6> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSharedUnmanaged(i), ref field1.RefSharedUnmanaged(i), ref field2.RefSharedUnmanaged(i), ref field3.RefSharedUnmanaged(i), ref field4.RefSharedUnmanaged(i), ref field5.RefSharedUnmanaged(i), ref field6.RefSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5, T6> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSparseUnmanaged(i), ref field1.RefSparseUnmanaged(i), ref field2.RefSparseUnmanaged(i), ref field3.RefSparseUnmanaged(i), ref field4.RefSparseUnmanaged(i), ref field5.RefSparseUnmanaged(i), ref field6.RefSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5, T6> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSparseSharedUnmanaged(i), ref field1.RefSparseSharedUnmanaged(i), ref field2.RefSparseSharedUnmanaged(i), ref field3.RefSparseSharedUnmanaged(i), ref field4.RefSparseSharedUnmanaged(i), ref field5.RefSparseSharedUnmanaged(i), ref field6.RefSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5, T6> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefManaged(i), ref field1.RefManaged(i), ref field2.RefManaged(i), ref field3.RefManaged(i), ref field4.RefManaged(i), ref field5.RefManaged(i), ref field6.RefManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5, T6> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSharedManaged(i), ref field1.RefSharedManaged(i), ref field2.RefSharedManaged(i), ref field3.RefSharedManaged(i), ref field4.RefSharedManaged(i), ref field5.RefSharedManaged(i), ref field6.RefSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5, T6> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSparseManaged(i), ref field1.RefSparseManaged(i), ref field2.RefSparseManaged(i), ref field3.RefSparseManaged(i), ref field4.RefSparseManaged(i), ref field5.RefSparseManaged(i), ref field6.RefSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5, T6> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSparseSharedManaged(i), ref field1.RefSparseSharedManaged(i), ref field2.RefSparseSharedManaged(i), ref field3.RefSparseSharedManaged(i), ref field4.RefSparseSharedManaged(i), ref field5.RefSparseSharedManaged(i), ref field6.RefSparseSharedManaged(i));
+        }
     }
 
     /// <summary>
@@ -38,15 +118,93 @@ public static void Each<T0, T1, T2, T3, T4, T5, T6>(Iter it, Ecs.EachEntityRefCa
     {
         int count = it.Handle->count; Ecs.Assert(it.Handle->count > 0, "No entities returned, use Iter() or Each() without the entity argument instead.");
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6);
+        IterationTechnique flags = it.GetIterationTechnique(7);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6])
-            callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref Managed.GetTypeRef<T0>(pointer0), ref Managed.GetTypeRef<T1>(pointer1), ref Managed.GetTypeRef<T2>(pointer2), ref Managed.GetTypeRef<T3>(pointer3), ref Managed.GetTypeRef<T4>(pointer4), ref Managed.GetTypeRef<T5>(pointer5), ref Managed.GetTypeRef<T6>(pointer6));
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5, T6> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefUnmanaged(i), ref field1.RefUnmanaged(i), ref field2.RefUnmanaged(i), ref field3.RefUnmanaged(i), ref field4.RefUnmanaged(i), ref field5.RefUnmanaged(i), ref field6.RefUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5, T6> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSharedUnmanaged(i), ref field1.RefSharedUnmanaged(i), ref field2.RefSharedUnmanaged(i), ref field3.RefSharedUnmanaged(i), ref field4.RefSharedUnmanaged(i), ref field5.RefSharedUnmanaged(i), ref field6.RefSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5, T6> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseUnmanaged(i), ref field1.RefSparseUnmanaged(i), ref field2.RefSparseUnmanaged(i), ref field3.RefSparseUnmanaged(i), ref field4.RefSparseUnmanaged(i), ref field5.RefSparseUnmanaged(i), ref field6.RefSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5, T6> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseSharedUnmanaged(i), ref field1.RefSparseSharedUnmanaged(i), ref field2.RefSparseSharedUnmanaged(i), ref field3.RefSparseSharedUnmanaged(i), ref field4.RefSparseSharedUnmanaged(i), ref field5.RefSparseSharedUnmanaged(i), ref field6.RefSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5, T6> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefManaged(i), ref field1.RefManaged(i), ref field2.RefManaged(i), ref field3.RefManaged(i), ref field4.RefManaged(i), ref field5.RefManaged(i), ref field6.RefManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5, T6> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSharedManaged(i), ref field1.RefSharedManaged(i), ref field2.RefSharedManaged(i), ref field3.RefSharedManaged(i), ref field4.RefSharedManaged(i), ref field5.RefSharedManaged(i), ref field6.RefSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5, T6> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseManaged(i), ref field1.RefSparseManaged(i), ref field2.RefSparseManaged(i), ref field3.RefSparseManaged(i), ref field4.RefSparseManaged(i), ref field5.RefSparseManaged(i), ref field6.RefSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5, T6> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseSharedManaged(i), ref field1.RefSparseSharedManaged(i), ref field2.RefSparseSharedManaged(i), ref field3.RefSparseSharedManaged(i), ref field4.RefSparseSharedManaged(i), ref field5.RefSparseSharedManaged(i), ref field6.RefSparseSharedManaged(i));
+        }
     }
 
     /// <summary>
@@ -59,15 +217,93 @@ public static void Each<T0, T1, T2, T3, T4, T5, T6>(Iter it, Ecs.EachIterRefCall
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6);
+        IterationTechnique flags = it.GetIterationTechnique(7);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6])
-            callback(it, i, ref Managed.GetTypeRef<T0>(pointer0), ref Managed.GetTypeRef<T1>(pointer1), ref Managed.GetTypeRef<T2>(pointer2), ref Managed.GetTypeRef<T3>(pointer3), ref Managed.GetTypeRef<T4>(pointer4), ref Managed.GetTypeRef<T5>(pointer5), ref Managed.GetTypeRef<T6>(pointer6));
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5, T6> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefUnmanaged(i), ref field1.RefUnmanaged(i), ref field2.RefUnmanaged(i), ref field3.RefUnmanaged(i), ref field4.RefUnmanaged(i), ref field5.RefUnmanaged(i), ref field6.RefUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5, T6> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSharedUnmanaged(i), ref field1.RefSharedUnmanaged(i), ref field2.RefSharedUnmanaged(i), ref field3.RefSharedUnmanaged(i), ref field4.RefSharedUnmanaged(i), ref field5.RefSharedUnmanaged(i), ref field6.RefSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5, T6> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSparseUnmanaged(i), ref field1.RefSparseUnmanaged(i), ref field2.RefSparseUnmanaged(i), ref field3.RefSparseUnmanaged(i), ref field4.RefSparseUnmanaged(i), ref field5.RefSparseUnmanaged(i), ref field6.RefSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5, T6> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSparseSharedUnmanaged(i), ref field1.RefSparseSharedUnmanaged(i), ref field2.RefSparseSharedUnmanaged(i), ref field3.RefSparseSharedUnmanaged(i), ref field4.RefSparseSharedUnmanaged(i), ref field5.RefSparseSharedUnmanaged(i), ref field6.RefSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5, T6> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefManaged(i), ref field1.RefManaged(i), ref field2.RefManaged(i), ref field3.RefManaged(i), ref field4.RefManaged(i), ref field5.RefManaged(i), ref field6.RefManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5, T6> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSharedManaged(i), ref field1.RefSharedManaged(i), ref field2.RefSharedManaged(i), ref field3.RefSharedManaged(i), ref field4.RefSharedManaged(i), ref field5.RefSharedManaged(i), ref field6.RefSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5, T6> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSparseManaged(i), ref field1.RefSparseManaged(i), ref field2.RefSparseManaged(i), ref field3.RefSparseManaged(i), ref field4.RefSparseManaged(i), ref field5.RefSparseManaged(i), ref field6.RefSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5, T6> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSparseSharedManaged(i), ref field1.RefSparseSharedManaged(i), ref field2.RefSparseSharedManaged(i), ref field3.RefSparseSharedManaged(i), ref field4.RefSparseSharedManaged(i), ref field5.RefSparseSharedManaged(i), ref field6.RefSparseSharedManaged(i));
+        }
     }
 
     /// <summary>
@@ -80,15 +316,93 @@ public static void Each<T0, T1, T2, T3, T4, T5, T6>(Iter it, delegate*<ref T0, r
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6);
+        IterationTechnique flags = it.GetIterationTechnique(7);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6])
-            callback(ref Managed.GetTypeRef<T0>(pointer0), ref Managed.GetTypeRef<T1>(pointer1), ref Managed.GetTypeRef<T2>(pointer2), ref Managed.GetTypeRef<T3>(pointer3), ref Managed.GetTypeRef<T4>(pointer4), ref Managed.GetTypeRef<T5>(pointer5), ref Managed.GetTypeRef<T6>(pointer6));
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefUnmanaged(i), ref field1.RefUnmanaged(i), ref field2.RefUnmanaged(i), ref field3.RefUnmanaged(i), ref field4.RefUnmanaged(i), ref field5.RefUnmanaged(i), ref field6.RefUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSharedUnmanaged(i), ref field1.RefSharedUnmanaged(i), ref field2.RefSharedUnmanaged(i), ref field3.RefSharedUnmanaged(i), ref field4.RefSharedUnmanaged(i), ref field5.RefSharedUnmanaged(i), ref field6.RefSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSparseUnmanaged(i), ref field1.RefSparseUnmanaged(i), ref field2.RefSparseUnmanaged(i), ref field3.RefSparseUnmanaged(i), ref field4.RefSparseUnmanaged(i), ref field5.RefSparseUnmanaged(i), ref field6.RefSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSparseSharedUnmanaged(i), ref field1.RefSparseSharedUnmanaged(i), ref field2.RefSparseSharedUnmanaged(i), ref field3.RefSparseSharedUnmanaged(i), ref field4.RefSparseSharedUnmanaged(i), ref field5.RefSparseSharedUnmanaged(i), ref field6.RefSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefManaged(i), ref field1.RefManaged(i), ref field2.RefManaged(i), ref field3.RefManaged(i), ref field4.RefManaged(i), ref field5.RefManaged(i), ref field6.RefManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSharedManaged(i), ref field1.RefSharedManaged(i), ref field2.RefSharedManaged(i), ref field3.RefSharedManaged(i), ref field4.RefSharedManaged(i), ref field5.RefSharedManaged(i), ref field6.RefSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSparseManaged(i), ref field1.RefSparseManaged(i), ref field2.RefSparseManaged(i), ref field3.RefSparseManaged(i), ref field4.RefSparseManaged(i), ref field5.RefSparseManaged(i), ref field6.RefSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSparseSharedManaged(i), ref field1.RefSparseSharedManaged(i), ref field2.RefSparseSharedManaged(i), ref field3.RefSparseSharedManaged(i), ref field4.RefSparseSharedManaged(i), ref field5.RefSparseSharedManaged(i), ref field6.RefSparseSharedManaged(i));
+        }
     }
 
     /// <summary>
@@ -101,15 +415,93 @@ public static void Each<T0, T1, T2, T3, T4, T5, T6>(Iter it, delegate*<Entity, r
     {
         int count = it.Handle->count; Ecs.Assert(it.Handle->count > 0, "No entities returned, use Iter() or Each() without the entity argument instead.");
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6);
+        IterationTechnique flags = it.GetIterationTechnique(7);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6])
-            callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref Managed.GetTypeRef<T0>(pointer0), ref Managed.GetTypeRef<T1>(pointer1), ref Managed.GetTypeRef<T2>(pointer2), ref Managed.GetTypeRef<T3>(pointer3), ref Managed.GetTypeRef<T4>(pointer4), ref Managed.GetTypeRef<T5>(pointer5), ref Managed.GetTypeRef<T6>(pointer6));
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefUnmanaged(i), ref field1.RefUnmanaged(i), ref field2.RefUnmanaged(i), ref field3.RefUnmanaged(i), ref field4.RefUnmanaged(i), ref field5.RefUnmanaged(i), ref field6.RefUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSharedUnmanaged(i), ref field1.RefSharedUnmanaged(i), ref field2.RefSharedUnmanaged(i), ref field3.RefSharedUnmanaged(i), ref field4.RefSharedUnmanaged(i), ref field5.RefSharedUnmanaged(i), ref field6.RefSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseUnmanaged(i), ref field1.RefSparseUnmanaged(i), ref field2.RefSparseUnmanaged(i), ref field3.RefSparseUnmanaged(i), ref field4.RefSparseUnmanaged(i), ref field5.RefSparseUnmanaged(i), ref field6.RefSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseSharedUnmanaged(i), ref field1.RefSparseSharedUnmanaged(i), ref field2.RefSparseSharedUnmanaged(i), ref field3.RefSparseSharedUnmanaged(i), ref field4.RefSparseSharedUnmanaged(i), ref field5.RefSparseSharedUnmanaged(i), ref field6.RefSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefManaged(i), ref field1.RefManaged(i), ref field2.RefManaged(i), ref field3.RefManaged(i), ref field4.RefManaged(i), ref field5.RefManaged(i), ref field6.RefManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSharedManaged(i), ref field1.RefSharedManaged(i), ref field2.RefSharedManaged(i), ref field3.RefSharedManaged(i), ref field4.RefSharedManaged(i), ref field5.RefSharedManaged(i), ref field6.RefSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseManaged(i), ref field1.RefSparseManaged(i), ref field2.RefSparseManaged(i), ref field3.RefSparseManaged(i), ref field4.RefSparseManaged(i), ref field5.RefSparseManaged(i), ref field6.RefSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseSharedManaged(i), ref field1.RefSparseSharedManaged(i), ref field2.RefSparseSharedManaged(i), ref field3.RefSparseSharedManaged(i), ref field4.RefSparseSharedManaged(i), ref field5.RefSparseSharedManaged(i), ref field6.RefSparseSharedManaged(i));
+        }
     }
 
     /// <summary>
@@ -122,15 +514,93 @@ public static void Each<T0, T1, T2, T3, T4, T5, T6>(Iter it, delegate*<Iter, int
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6);
+        IterationTechnique flags = it.GetIterationTechnique(7);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6])
-            callback(it, i, ref Managed.GetTypeRef<T0>(pointer0), ref Managed.GetTypeRef<T1>(pointer1), ref Managed.GetTypeRef<T2>(pointer2), ref Managed.GetTypeRef<T3>(pointer3), ref Managed.GetTypeRef<T4>(pointer4), ref Managed.GetTypeRef<T5>(pointer5), ref Managed.GetTypeRef<T6>(pointer6));
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefUnmanaged(i), ref field1.RefUnmanaged(i), ref field2.RefUnmanaged(i), ref field3.RefUnmanaged(i), ref field4.RefUnmanaged(i), ref field5.RefUnmanaged(i), ref field6.RefUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSharedUnmanaged(i), ref field1.RefSharedUnmanaged(i), ref field2.RefSharedUnmanaged(i), ref field3.RefSharedUnmanaged(i), ref field4.RefSharedUnmanaged(i), ref field5.RefSharedUnmanaged(i), ref field6.RefSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSparseUnmanaged(i), ref field1.RefSparseUnmanaged(i), ref field2.RefSparseUnmanaged(i), ref field3.RefSparseUnmanaged(i), ref field4.RefSparseUnmanaged(i), ref field5.RefSparseUnmanaged(i), ref field6.RefSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSparseSharedUnmanaged(i), ref field1.RefSparseSharedUnmanaged(i), ref field2.RefSparseSharedUnmanaged(i), ref field3.RefSparseSharedUnmanaged(i), ref field4.RefSparseSharedUnmanaged(i), ref field5.RefSparseSharedUnmanaged(i), ref field6.RefSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefManaged(i), ref field1.RefManaged(i), ref field2.RefManaged(i), ref field3.RefManaged(i), ref field4.RefManaged(i), ref field5.RefManaged(i), ref field6.RefManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSharedManaged(i), ref field1.RefSharedManaged(i), ref field2.RefSharedManaged(i), ref field3.RefSharedManaged(i), ref field4.RefSharedManaged(i), ref field5.RefSharedManaged(i), ref field6.RefSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSparseManaged(i), ref field1.RefSparseManaged(i), ref field2.RefSparseManaged(i), ref field3.RefSparseManaged(i), ref field4.RefSparseManaged(i), ref field5.RefSparseManaged(i), ref field6.RefSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSparseSharedManaged(i), ref field1.RefSparseSharedManaged(i), ref field2.RefSparseSharedManaged(i), ref field3.RefSparseSharedManaged(i), ref field4.RefSparseSharedManaged(i), ref field5.RefSparseSharedManaged(i), ref field6.RefSparseSharedManaged(i));
+        }
     }
 
     /// <summary>
@@ -143,15 +613,93 @@ public static void Each<T0, T1, T2, T3, T4, T5, T6>(Iter it, Ecs.EachPointerCall
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6);
+        IterationTechnique flags = it.GetIterationTechnique(7);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6])
-            callback((T0*)pointer0, (T1*)pointer1, (T2*)pointer2, (T3*)pointer3, (T4*)pointer4, (T5*)pointer5, (T6*)pointer6);
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5, T6> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerUnmanaged(i), field1.PointerUnmanaged(i), field2.PointerUnmanaged(i), field3.PointerUnmanaged(i), field4.PointerUnmanaged(i), field5.PointerUnmanaged(i), field6.PointerUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5, T6> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSharedUnmanaged(i), field1.PointerSharedUnmanaged(i), field2.PointerSharedUnmanaged(i), field3.PointerSharedUnmanaged(i), field4.PointerSharedUnmanaged(i), field5.PointerSharedUnmanaged(i), field6.PointerSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5, T6> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSparseUnmanaged(i), field1.PointerSparseUnmanaged(i), field2.PointerSparseUnmanaged(i), field3.PointerSparseUnmanaged(i), field4.PointerSparseUnmanaged(i), field5.PointerSparseUnmanaged(i), field6.PointerSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5, T6> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSparseSharedUnmanaged(i), field1.PointerSparseSharedUnmanaged(i), field2.PointerSparseSharedUnmanaged(i), field3.PointerSparseSharedUnmanaged(i), field4.PointerSparseSharedUnmanaged(i), field5.PointerSparseSharedUnmanaged(i), field6.PointerSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5, T6> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerManaged(i), field1.PointerManaged(i), field2.PointerManaged(i), field3.PointerManaged(i), field4.PointerManaged(i), field5.PointerManaged(i), field6.PointerManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5, T6> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSharedManaged(i), field1.PointerSharedManaged(i), field2.PointerSharedManaged(i), field3.PointerSharedManaged(i), field4.PointerSharedManaged(i), field5.PointerSharedManaged(i), field6.PointerSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5, T6> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSparseManaged(i), field1.PointerSparseManaged(i), field2.PointerSparseManaged(i), field3.PointerSparseManaged(i), field4.PointerSparseManaged(i), field5.PointerSparseManaged(i), field6.PointerSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5, T6> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSparseSharedManaged(i), field1.PointerSparseSharedManaged(i), field2.PointerSparseSharedManaged(i), field3.PointerSparseSharedManaged(i), field4.PointerSparseSharedManaged(i), field5.PointerSparseSharedManaged(i), field6.PointerSparseSharedManaged(i));
+        }
     }
 
     /// <summary>
@@ -164,15 +712,93 @@ public static void Each<T0, T1, T2, T3, T4, T5, T6>(Iter it, Ecs.EachEntityPoint
     {
         int count = it.Handle->count; Ecs.Assert(it.Handle->count > 0, "No entities returned, use Iter() or Each() without the entity argument instead.");
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6);
+        IterationTechnique flags = it.GetIterationTechnique(7);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6])
-            callback(new Entity(it.Handle->world, it.Handle->entities[i]), (T0*)pointer0, (T1*)pointer1, (T2*)pointer2, (T3*)pointer3, (T4*)pointer4, (T5*)pointer5, (T6*)pointer6);
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerUnmanaged(i), field1.PointerUnmanaged(i), field2.PointerUnmanaged(i), field3.PointerUnmanaged(i), field4.PointerUnmanaged(i), field5.PointerUnmanaged(i), field6.PointerUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSharedUnmanaged(i), field1.PointerSharedUnmanaged(i), field2.PointerSharedUnmanaged(i), field3.PointerSharedUnmanaged(i), field4.PointerSharedUnmanaged(i), field5.PointerSharedUnmanaged(i), field6.PointerSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseUnmanaged(i), field1.PointerSparseUnmanaged(i), field2.PointerSparseUnmanaged(i), field3.PointerSparseUnmanaged(i), field4.PointerSparseUnmanaged(i), field5.PointerSparseUnmanaged(i), field6.PointerSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseSharedUnmanaged(i), field1.PointerSparseSharedUnmanaged(i), field2.PointerSparseSharedUnmanaged(i), field3.PointerSparseSharedUnmanaged(i), field4.PointerSparseSharedUnmanaged(i), field5.PointerSparseSharedUnmanaged(i), field6.PointerSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerManaged(i), field1.PointerManaged(i), field2.PointerManaged(i), field3.PointerManaged(i), field4.PointerManaged(i), field5.PointerManaged(i), field6.PointerManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSharedManaged(i), field1.PointerSharedManaged(i), field2.PointerSharedManaged(i), field3.PointerSharedManaged(i), field4.PointerSharedManaged(i), field5.PointerSharedManaged(i), field6.PointerSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseManaged(i), field1.PointerSparseManaged(i), field2.PointerSparseManaged(i), field3.PointerSparseManaged(i), field4.PointerSparseManaged(i), field5.PointerSparseManaged(i), field6.PointerSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseSharedManaged(i), field1.PointerSparseSharedManaged(i), field2.PointerSparseSharedManaged(i), field3.PointerSparseSharedManaged(i), field4.PointerSparseSharedManaged(i), field5.PointerSparseSharedManaged(i), field6.PointerSparseSharedManaged(i));
+        }
     }
 
     /// <summary>
@@ -185,15 +811,93 @@ public static void Each<T0, T1, T2, T3, T4, T5, T6>(Iter it, Ecs.EachIterPointer
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6);
+        IterationTechnique flags = it.GetIterationTechnique(7);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6])
-            callback(it, i, (T0*)pointer0, (T1*)pointer1, (T2*)pointer2, (T3*)pointer3, (T4*)pointer4, (T5*)pointer5, (T6*)pointer6);
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5, T6> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerUnmanaged(i), field1.PointerUnmanaged(i), field2.PointerUnmanaged(i), field3.PointerUnmanaged(i), field4.PointerUnmanaged(i), field5.PointerUnmanaged(i), field6.PointerUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5, T6> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSharedUnmanaged(i), field1.PointerSharedUnmanaged(i), field2.PointerSharedUnmanaged(i), field3.PointerSharedUnmanaged(i), field4.PointerSharedUnmanaged(i), field5.PointerSharedUnmanaged(i), field6.PointerSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5, T6> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSparseUnmanaged(i), field1.PointerSparseUnmanaged(i), field2.PointerSparseUnmanaged(i), field3.PointerSparseUnmanaged(i), field4.PointerSparseUnmanaged(i), field5.PointerSparseUnmanaged(i), field6.PointerSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5, T6> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSparseSharedUnmanaged(i), field1.PointerSparseSharedUnmanaged(i), field2.PointerSparseSharedUnmanaged(i), field3.PointerSparseSharedUnmanaged(i), field4.PointerSparseSharedUnmanaged(i), field5.PointerSparseSharedUnmanaged(i), field6.PointerSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5, T6> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerManaged(i), field1.PointerManaged(i), field2.PointerManaged(i), field3.PointerManaged(i), field4.PointerManaged(i), field5.PointerManaged(i), field6.PointerManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5, T6> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSharedManaged(i), field1.PointerSharedManaged(i), field2.PointerSharedManaged(i), field3.PointerSharedManaged(i), field4.PointerSharedManaged(i), field5.PointerSharedManaged(i), field6.PointerSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5, T6> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSparseManaged(i), field1.PointerSparseManaged(i), field2.PointerSparseManaged(i), field3.PointerSparseManaged(i), field4.PointerSparseManaged(i), field5.PointerSparseManaged(i), field6.PointerSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5, T6> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSparseSharedManaged(i), field1.PointerSparseSharedManaged(i), field2.PointerSparseSharedManaged(i), field3.PointerSparseSharedManaged(i), field4.PointerSparseSharedManaged(i), field5.PointerSparseSharedManaged(i), field6.PointerSparseSharedManaged(i));
+        }
     }
 
     /// <summary>
@@ -206,15 +910,93 @@ public static void Each<T0, T1, T2, T3, T4, T5, T6>(Iter it, delegate*<T0*, T1*,
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6);
+        IterationTechnique flags = it.GetIterationTechnique(7);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6])
-            callback((T0*)pointer0, (T1*)pointer1, (T2*)pointer2, (T3*)pointer3, (T4*)pointer4, (T5*)pointer5, (T6*)pointer6);
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerUnmanaged(i), field1.PointerUnmanaged(i), field2.PointerUnmanaged(i), field3.PointerUnmanaged(i), field4.PointerUnmanaged(i), field5.PointerUnmanaged(i), field6.PointerUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSharedUnmanaged(i), field1.PointerSharedUnmanaged(i), field2.PointerSharedUnmanaged(i), field3.PointerSharedUnmanaged(i), field4.PointerSharedUnmanaged(i), field5.PointerSharedUnmanaged(i), field6.PointerSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSparseUnmanaged(i), field1.PointerSparseUnmanaged(i), field2.PointerSparseUnmanaged(i), field3.PointerSparseUnmanaged(i), field4.PointerSparseUnmanaged(i), field5.PointerSparseUnmanaged(i), field6.PointerSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSparseSharedUnmanaged(i), field1.PointerSparseSharedUnmanaged(i), field2.PointerSparseSharedUnmanaged(i), field3.PointerSparseSharedUnmanaged(i), field4.PointerSparseSharedUnmanaged(i), field5.PointerSparseSharedUnmanaged(i), field6.PointerSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerManaged(i), field1.PointerManaged(i), field2.PointerManaged(i), field3.PointerManaged(i), field4.PointerManaged(i), field5.PointerManaged(i), field6.PointerManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSharedManaged(i), field1.PointerSharedManaged(i), field2.PointerSharedManaged(i), field3.PointerSharedManaged(i), field4.PointerSharedManaged(i), field5.PointerSharedManaged(i), field6.PointerSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSparseManaged(i), field1.PointerSparseManaged(i), field2.PointerSparseManaged(i), field3.PointerSparseManaged(i), field4.PointerSparseManaged(i), field5.PointerSparseManaged(i), field6.PointerSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSparseSharedManaged(i), field1.PointerSparseSharedManaged(i), field2.PointerSparseSharedManaged(i), field3.PointerSparseSharedManaged(i), field4.PointerSparseSharedManaged(i), field5.PointerSparseSharedManaged(i), field6.PointerSparseSharedManaged(i));
+        }
     }
 
     /// <summary>
@@ -227,15 +1009,93 @@ public static void Each<T0, T1, T2, T3, T4, T5, T6>(Iter it, delegate*<Entity, T
     {
         int count = it.Handle->count; Ecs.Assert(it.Handle->count > 0, "No entities returned, use Iter() or Each() without the entity argument instead.");
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6);
+        IterationTechnique flags = it.GetIterationTechnique(7);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6])
-            callback(new Entity(it.Handle->world, it.Handle->entities[i]), (T0*)pointer0, (T1*)pointer1, (T2*)pointer2, (T3*)pointer3, (T4*)pointer4, (T5*)pointer5, (T6*)pointer6);
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerUnmanaged(i), field1.PointerUnmanaged(i), field2.PointerUnmanaged(i), field3.PointerUnmanaged(i), field4.PointerUnmanaged(i), field5.PointerUnmanaged(i), field6.PointerUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSharedUnmanaged(i), field1.PointerSharedUnmanaged(i), field2.PointerSharedUnmanaged(i), field3.PointerSharedUnmanaged(i), field4.PointerSharedUnmanaged(i), field5.PointerSharedUnmanaged(i), field6.PointerSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseUnmanaged(i), field1.PointerSparseUnmanaged(i), field2.PointerSparseUnmanaged(i), field3.PointerSparseUnmanaged(i), field4.PointerSparseUnmanaged(i), field5.PointerSparseUnmanaged(i), field6.PointerSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseSharedUnmanaged(i), field1.PointerSparseSharedUnmanaged(i), field2.PointerSparseSharedUnmanaged(i), field3.PointerSparseSharedUnmanaged(i), field4.PointerSparseSharedUnmanaged(i), field5.PointerSparseSharedUnmanaged(i), field6.PointerSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerManaged(i), field1.PointerManaged(i), field2.PointerManaged(i), field3.PointerManaged(i), field4.PointerManaged(i), field5.PointerManaged(i), field6.PointerManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSharedManaged(i), field1.PointerSharedManaged(i), field2.PointerSharedManaged(i), field3.PointerSharedManaged(i), field4.PointerSharedManaged(i), field5.PointerSharedManaged(i), field6.PointerSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseManaged(i), field1.PointerSparseManaged(i), field2.PointerSparseManaged(i), field3.PointerSparseManaged(i), field4.PointerSparseManaged(i), field5.PointerSparseManaged(i), field6.PointerSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseSharedManaged(i), field1.PointerSparseSharedManaged(i), field2.PointerSparseSharedManaged(i), field3.PointerSparseSharedManaged(i), field4.PointerSparseSharedManaged(i), field5.PointerSparseSharedManaged(i), field6.PointerSparseSharedManaged(i));
+        }
     }
 
     /// <summary>
@@ -248,14 +1108,92 @@ public static void Each<T0, T1, T2, T3, T4, T5, T6>(Iter it, delegate*<Iter, int
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6);
+        IterationTechnique flags = it.GetIterationTechnique(7);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6])
-            callback(it, i, (T0*)pointer0, (T1*)pointer1, (T2*)pointer2, (T3*)pointer3, (T4*)pointer4, (T5*)pointer5, (T6*)pointer6);
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerUnmanaged(i), field1.PointerUnmanaged(i), field2.PointerUnmanaged(i), field3.PointerUnmanaged(i), field4.PointerUnmanaged(i), field5.PointerUnmanaged(i), field6.PointerUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSharedUnmanaged(i), field1.PointerSharedUnmanaged(i), field2.PointerSharedUnmanaged(i), field3.PointerSharedUnmanaged(i), field4.PointerSharedUnmanaged(i), field5.PointerSharedUnmanaged(i), field6.PointerSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSparseUnmanaged(i), field1.PointerSparseUnmanaged(i), field2.PointerSparseUnmanaged(i), field3.PointerSparseUnmanaged(i), field4.PointerSparseUnmanaged(i), field5.PointerSparseUnmanaged(i), field6.PointerSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSparseSharedUnmanaged(i), field1.PointerSparseSharedUnmanaged(i), field2.PointerSparseSharedUnmanaged(i), field3.PointerSparseSharedUnmanaged(i), field4.PointerSparseSharedUnmanaged(i), field5.PointerSparseSharedUnmanaged(i), field6.PointerSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerManaged(i), field1.PointerManaged(i), field2.PointerManaged(i), field3.PointerManaged(i), field4.PointerManaged(i), field5.PointerManaged(i), field6.PointerManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSharedManaged(i), field1.PointerSharedManaged(i), field2.PointerSharedManaged(i), field3.PointerSharedManaged(i), field4.PointerSharedManaged(i), field5.PointerSharedManaged(i), field6.PointerSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSparseManaged(i), field1.PointerSparseManaged(i), field2.PointerSparseManaged(i), field3.PointerSparseManaged(i), field4.PointerSparseManaged(i), field5.PointerSparseManaged(i), field6.PointerSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSparseSharedManaged(i), field1.PointerSparseSharedManaged(i), field2.PointerSparseSharedManaged(i), field3.PointerSparseSharedManaged(i), field4.PointerSparseSharedManaged(i), field5.PointerSparseSharedManaged(i), field6.PointerSparseSharedManaged(i));
+        }
     }
 }
\ No newline at end of file
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/Invoker/Each/Iterator/T8.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/Invoker/Each/Iterator/T8.g.cs
index 8bb05d21..fe4daad1 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/Invoker/Each/Iterator/T8.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/Invoker/Each/Iterator/T8.g.cs
@@ -1,5 +1,7 @@
 // Each/Iterator/T8.g.cs
 // File was auto-generated by /_/src/Flecs.NET.Codegen/Generators/Invoker.cs
+using System;
+using System.Runtime.CompilerServices;
 using Flecs.NET.Utilities;
 using static Flecs.NET.Bindings.flecs;
 
@@ -17,15 +19,93 @@ public static void Each<T0, T1, T2, T3, T4, T5, T6, T7>(Iter it, Ecs.EachRefCall
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7);
+        IterationTechnique flags = it.GetIterationTechnique(8);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7])
-            callback(ref Managed.GetTypeRef<T0>(pointer0), ref Managed.GetTypeRef<T1>(pointer1), ref Managed.GetTypeRef<T2>(pointer2), ref Managed.GetTypeRef<T3>(pointer3), ref Managed.GetTypeRef<T4>(pointer4), ref Managed.GetTypeRef<T5>(pointer5), ref Managed.GetTypeRef<T6>(pointer6), ref Managed.GetTypeRef<T7>(pointer7));
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5, T6, T7> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefUnmanaged(i), ref field1.RefUnmanaged(i), ref field2.RefUnmanaged(i), ref field3.RefUnmanaged(i), ref field4.RefUnmanaged(i), ref field5.RefUnmanaged(i), ref field6.RefUnmanaged(i), ref field7.RefUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5, T6, T7> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSharedUnmanaged(i), ref field1.RefSharedUnmanaged(i), ref field2.RefSharedUnmanaged(i), ref field3.RefSharedUnmanaged(i), ref field4.RefSharedUnmanaged(i), ref field5.RefSharedUnmanaged(i), ref field6.RefSharedUnmanaged(i), ref field7.RefSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5, T6, T7> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSparseUnmanaged(i), ref field1.RefSparseUnmanaged(i), ref field2.RefSparseUnmanaged(i), ref field3.RefSparseUnmanaged(i), ref field4.RefSparseUnmanaged(i), ref field5.RefSparseUnmanaged(i), ref field6.RefSparseUnmanaged(i), ref field7.RefSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5, T6, T7> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSparseSharedUnmanaged(i), ref field1.RefSparseSharedUnmanaged(i), ref field2.RefSparseSharedUnmanaged(i), ref field3.RefSparseSharedUnmanaged(i), ref field4.RefSparseSharedUnmanaged(i), ref field5.RefSparseSharedUnmanaged(i), ref field6.RefSparseSharedUnmanaged(i), ref field7.RefSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5, T6, T7> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefManaged(i), ref field1.RefManaged(i), ref field2.RefManaged(i), ref field3.RefManaged(i), ref field4.RefManaged(i), ref field5.RefManaged(i), ref field6.RefManaged(i), ref field7.RefManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5, T6, T7> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSharedManaged(i), ref field1.RefSharedManaged(i), ref field2.RefSharedManaged(i), ref field3.RefSharedManaged(i), ref field4.RefSharedManaged(i), ref field5.RefSharedManaged(i), ref field6.RefSharedManaged(i), ref field7.RefSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5, T6, T7> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSparseManaged(i), ref field1.RefSparseManaged(i), ref field2.RefSparseManaged(i), ref field3.RefSparseManaged(i), ref field4.RefSparseManaged(i), ref field5.RefSparseManaged(i), ref field6.RefSparseManaged(i), ref field7.RefSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5, T6, T7> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSparseSharedManaged(i), ref field1.RefSparseSharedManaged(i), ref field2.RefSparseSharedManaged(i), ref field3.RefSparseSharedManaged(i), ref field4.RefSparseSharedManaged(i), ref field5.RefSparseSharedManaged(i), ref field6.RefSparseSharedManaged(i), ref field7.RefSparseSharedManaged(i));
+        }
     }
 
     /// <summary>
@@ -38,15 +118,93 @@ public static void Each<T0, T1, T2, T3, T4, T5, T6, T7>(Iter it, Ecs.EachEntityR
     {
         int count = it.Handle->count; Ecs.Assert(it.Handle->count > 0, "No entities returned, use Iter() or Each() without the entity argument instead.");
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7);
+        IterationTechnique flags = it.GetIterationTechnique(8);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7])
-            callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref Managed.GetTypeRef<T0>(pointer0), ref Managed.GetTypeRef<T1>(pointer1), ref Managed.GetTypeRef<T2>(pointer2), ref Managed.GetTypeRef<T3>(pointer3), ref Managed.GetTypeRef<T4>(pointer4), ref Managed.GetTypeRef<T5>(pointer5), ref Managed.GetTypeRef<T6>(pointer6), ref Managed.GetTypeRef<T7>(pointer7));
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefUnmanaged(i), ref field1.RefUnmanaged(i), ref field2.RefUnmanaged(i), ref field3.RefUnmanaged(i), ref field4.RefUnmanaged(i), ref field5.RefUnmanaged(i), ref field6.RefUnmanaged(i), ref field7.RefUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSharedUnmanaged(i), ref field1.RefSharedUnmanaged(i), ref field2.RefSharedUnmanaged(i), ref field3.RefSharedUnmanaged(i), ref field4.RefSharedUnmanaged(i), ref field5.RefSharedUnmanaged(i), ref field6.RefSharedUnmanaged(i), ref field7.RefSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseUnmanaged(i), ref field1.RefSparseUnmanaged(i), ref field2.RefSparseUnmanaged(i), ref field3.RefSparseUnmanaged(i), ref field4.RefSparseUnmanaged(i), ref field5.RefSparseUnmanaged(i), ref field6.RefSparseUnmanaged(i), ref field7.RefSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseSharedUnmanaged(i), ref field1.RefSparseSharedUnmanaged(i), ref field2.RefSparseSharedUnmanaged(i), ref field3.RefSparseSharedUnmanaged(i), ref field4.RefSparseSharedUnmanaged(i), ref field5.RefSparseSharedUnmanaged(i), ref field6.RefSparseSharedUnmanaged(i), ref field7.RefSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefManaged(i), ref field1.RefManaged(i), ref field2.RefManaged(i), ref field3.RefManaged(i), ref field4.RefManaged(i), ref field5.RefManaged(i), ref field6.RefManaged(i), ref field7.RefManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSharedManaged(i), ref field1.RefSharedManaged(i), ref field2.RefSharedManaged(i), ref field3.RefSharedManaged(i), ref field4.RefSharedManaged(i), ref field5.RefSharedManaged(i), ref field6.RefSharedManaged(i), ref field7.RefSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseManaged(i), ref field1.RefSparseManaged(i), ref field2.RefSparseManaged(i), ref field3.RefSparseManaged(i), ref field4.RefSparseManaged(i), ref field5.RefSparseManaged(i), ref field6.RefSparseManaged(i), ref field7.RefSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseSharedManaged(i), ref field1.RefSparseSharedManaged(i), ref field2.RefSparseSharedManaged(i), ref field3.RefSparseSharedManaged(i), ref field4.RefSparseSharedManaged(i), ref field5.RefSparseSharedManaged(i), ref field6.RefSparseSharedManaged(i), ref field7.RefSparseSharedManaged(i));
+        }
     }
 
     /// <summary>
@@ -59,15 +217,93 @@ public static void Each<T0, T1, T2, T3, T4, T5, T6, T7>(Iter it, Ecs.EachIterRef
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7);
+        IterationTechnique flags = it.GetIterationTechnique(8);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7])
-            callback(it, i, ref Managed.GetTypeRef<T0>(pointer0), ref Managed.GetTypeRef<T1>(pointer1), ref Managed.GetTypeRef<T2>(pointer2), ref Managed.GetTypeRef<T3>(pointer3), ref Managed.GetTypeRef<T4>(pointer4), ref Managed.GetTypeRef<T5>(pointer5), ref Managed.GetTypeRef<T6>(pointer6), ref Managed.GetTypeRef<T7>(pointer7));
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefUnmanaged(i), ref field1.RefUnmanaged(i), ref field2.RefUnmanaged(i), ref field3.RefUnmanaged(i), ref field4.RefUnmanaged(i), ref field5.RefUnmanaged(i), ref field6.RefUnmanaged(i), ref field7.RefUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSharedUnmanaged(i), ref field1.RefSharedUnmanaged(i), ref field2.RefSharedUnmanaged(i), ref field3.RefSharedUnmanaged(i), ref field4.RefSharedUnmanaged(i), ref field5.RefSharedUnmanaged(i), ref field6.RefSharedUnmanaged(i), ref field7.RefSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSparseUnmanaged(i), ref field1.RefSparseUnmanaged(i), ref field2.RefSparseUnmanaged(i), ref field3.RefSparseUnmanaged(i), ref field4.RefSparseUnmanaged(i), ref field5.RefSparseUnmanaged(i), ref field6.RefSparseUnmanaged(i), ref field7.RefSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSparseSharedUnmanaged(i), ref field1.RefSparseSharedUnmanaged(i), ref field2.RefSparseSharedUnmanaged(i), ref field3.RefSparseSharedUnmanaged(i), ref field4.RefSparseSharedUnmanaged(i), ref field5.RefSparseSharedUnmanaged(i), ref field6.RefSparseSharedUnmanaged(i), ref field7.RefSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefManaged(i), ref field1.RefManaged(i), ref field2.RefManaged(i), ref field3.RefManaged(i), ref field4.RefManaged(i), ref field5.RefManaged(i), ref field6.RefManaged(i), ref field7.RefManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSharedManaged(i), ref field1.RefSharedManaged(i), ref field2.RefSharedManaged(i), ref field3.RefSharedManaged(i), ref field4.RefSharedManaged(i), ref field5.RefSharedManaged(i), ref field6.RefSharedManaged(i), ref field7.RefSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSparseManaged(i), ref field1.RefSparseManaged(i), ref field2.RefSparseManaged(i), ref field3.RefSparseManaged(i), ref field4.RefSparseManaged(i), ref field5.RefSparseManaged(i), ref field6.RefSparseManaged(i), ref field7.RefSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSparseSharedManaged(i), ref field1.RefSparseSharedManaged(i), ref field2.RefSparseSharedManaged(i), ref field3.RefSparseSharedManaged(i), ref field4.RefSparseSharedManaged(i), ref field5.RefSparseSharedManaged(i), ref field6.RefSparseSharedManaged(i), ref field7.RefSparseSharedManaged(i));
+        }
     }
 
     /// <summary>
@@ -80,15 +316,93 @@ public static void Each<T0, T1, T2, T3, T4, T5, T6, T7>(Iter it, delegate*<ref T
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7);
+        IterationTechnique flags = it.GetIterationTechnique(8);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7])
-            callback(ref Managed.GetTypeRef<T0>(pointer0), ref Managed.GetTypeRef<T1>(pointer1), ref Managed.GetTypeRef<T2>(pointer2), ref Managed.GetTypeRef<T3>(pointer3), ref Managed.GetTypeRef<T4>(pointer4), ref Managed.GetTypeRef<T5>(pointer5), ref Managed.GetTypeRef<T6>(pointer6), ref Managed.GetTypeRef<T7>(pointer7));
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefUnmanaged(i), ref field1.RefUnmanaged(i), ref field2.RefUnmanaged(i), ref field3.RefUnmanaged(i), ref field4.RefUnmanaged(i), ref field5.RefUnmanaged(i), ref field6.RefUnmanaged(i), ref field7.RefUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSharedUnmanaged(i), ref field1.RefSharedUnmanaged(i), ref field2.RefSharedUnmanaged(i), ref field3.RefSharedUnmanaged(i), ref field4.RefSharedUnmanaged(i), ref field5.RefSharedUnmanaged(i), ref field6.RefSharedUnmanaged(i), ref field7.RefSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSparseUnmanaged(i), ref field1.RefSparseUnmanaged(i), ref field2.RefSparseUnmanaged(i), ref field3.RefSparseUnmanaged(i), ref field4.RefSparseUnmanaged(i), ref field5.RefSparseUnmanaged(i), ref field6.RefSparseUnmanaged(i), ref field7.RefSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSparseSharedUnmanaged(i), ref field1.RefSparseSharedUnmanaged(i), ref field2.RefSparseSharedUnmanaged(i), ref field3.RefSparseSharedUnmanaged(i), ref field4.RefSparseSharedUnmanaged(i), ref field5.RefSparseSharedUnmanaged(i), ref field6.RefSparseSharedUnmanaged(i), ref field7.RefSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefManaged(i), ref field1.RefManaged(i), ref field2.RefManaged(i), ref field3.RefManaged(i), ref field4.RefManaged(i), ref field5.RefManaged(i), ref field6.RefManaged(i), ref field7.RefManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSharedManaged(i), ref field1.RefSharedManaged(i), ref field2.RefSharedManaged(i), ref field3.RefSharedManaged(i), ref field4.RefSharedManaged(i), ref field5.RefSharedManaged(i), ref field6.RefSharedManaged(i), ref field7.RefSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSparseManaged(i), ref field1.RefSparseManaged(i), ref field2.RefSparseManaged(i), ref field3.RefSparseManaged(i), ref field4.RefSparseManaged(i), ref field5.RefSparseManaged(i), ref field6.RefSparseManaged(i), ref field7.RefSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSparseSharedManaged(i), ref field1.RefSparseSharedManaged(i), ref field2.RefSparseSharedManaged(i), ref field3.RefSparseSharedManaged(i), ref field4.RefSparseSharedManaged(i), ref field5.RefSparseSharedManaged(i), ref field6.RefSparseSharedManaged(i), ref field7.RefSparseSharedManaged(i));
+        }
     }
 
     /// <summary>
@@ -101,15 +415,93 @@ public static void Each<T0, T1, T2, T3, T4, T5, T6, T7>(Iter it, delegate*<Entit
     {
         int count = it.Handle->count; Ecs.Assert(it.Handle->count > 0, "No entities returned, use Iter() or Each() without the entity argument instead.");
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7);
+        IterationTechnique flags = it.GetIterationTechnique(8);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7])
-            callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref Managed.GetTypeRef<T0>(pointer0), ref Managed.GetTypeRef<T1>(pointer1), ref Managed.GetTypeRef<T2>(pointer2), ref Managed.GetTypeRef<T3>(pointer3), ref Managed.GetTypeRef<T4>(pointer4), ref Managed.GetTypeRef<T5>(pointer5), ref Managed.GetTypeRef<T6>(pointer6), ref Managed.GetTypeRef<T7>(pointer7));
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefUnmanaged(i), ref field1.RefUnmanaged(i), ref field2.RefUnmanaged(i), ref field3.RefUnmanaged(i), ref field4.RefUnmanaged(i), ref field5.RefUnmanaged(i), ref field6.RefUnmanaged(i), ref field7.RefUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSharedUnmanaged(i), ref field1.RefSharedUnmanaged(i), ref field2.RefSharedUnmanaged(i), ref field3.RefSharedUnmanaged(i), ref field4.RefSharedUnmanaged(i), ref field5.RefSharedUnmanaged(i), ref field6.RefSharedUnmanaged(i), ref field7.RefSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseUnmanaged(i), ref field1.RefSparseUnmanaged(i), ref field2.RefSparseUnmanaged(i), ref field3.RefSparseUnmanaged(i), ref field4.RefSparseUnmanaged(i), ref field5.RefSparseUnmanaged(i), ref field6.RefSparseUnmanaged(i), ref field7.RefSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseSharedUnmanaged(i), ref field1.RefSparseSharedUnmanaged(i), ref field2.RefSparseSharedUnmanaged(i), ref field3.RefSparseSharedUnmanaged(i), ref field4.RefSparseSharedUnmanaged(i), ref field5.RefSparseSharedUnmanaged(i), ref field6.RefSparseSharedUnmanaged(i), ref field7.RefSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefManaged(i), ref field1.RefManaged(i), ref field2.RefManaged(i), ref field3.RefManaged(i), ref field4.RefManaged(i), ref field5.RefManaged(i), ref field6.RefManaged(i), ref field7.RefManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSharedManaged(i), ref field1.RefSharedManaged(i), ref field2.RefSharedManaged(i), ref field3.RefSharedManaged(i), ref field4.RefSharedManaged(i), ref field5.RefSharedManaged(i), ref field6.RefSharedManaged(i), ref field7.RefSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseManaged(i), ref field1.RefSparseManaged(i), ref field2.RefSparseManaged(i), ref field3.RefSparseManaged(i), ref field4.RefSparseManaged(i), ref field5.RefSparseManaged(i), ref field6.RefSparseManaged(i), ref field7.RefSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseSharedManaged(i), ref field1.RefSparseSharedManaged(i), ref field2.RefSparseSharedManaged(i), ref field3.RefSparseSharedManaged(i), ref field4.RefSparseSharedManaged(i), ref field5.RefSparseSharedManaged(i), ref field6.RefSparseSharedManaged(i), ref field7.RefSparseSharedManaged(i));
+        }
     }
 
     /// <summary>
@@ -122,15 +514,93 @@ public static void Each<T0, T1, T2, T3, T4, T5, T6, T7>(Iter it, delegate*<Iter,
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7);
+        IterationTechnique flags = it.GetIterationTechnique(8);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7])
-            callback(it, i, ref Managed.GetTypeRef<T0>(pointer0), ref Managed.GetTypeRef<T1>(pointer1), ref Managed.GetTypeRef<T2>(pointer2), ref Managed.GetTypeRef<T3>(pointer3), ref Managed.GetTypeRef<T4>(pointer4), ref Managed.GetTypeRef<T5>(pointer5), ref Managed.GetTypeRef<T6>(pointer6), ref Managed.GetTypeRef<T7>(pointer7));
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefUnmanaged(i), ref field1.RefUnmanaged(i), ref field2.RefUnmanaged(i), ref field3.RefUnmanaged(i), ref field4.RefUnmanaged(i), ref field5.RefUnmanaged(i), ref field6.RefUnmanaged(i), ref field7.RefUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSharedUnmanaged(i), ref field1.RefSharedUnmanaged(i), ref field2.RefSharedUnmanaged(i), ref field3.RefSharedUnmanaged(i), ref field4.RefSharedUnmanaged(i), ref field5.RefSharedUnmanaged(i), ref field6.RefSharedUnmanaged(i), ref field7.RefSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSparseUnmanaged(i), ref field1.RefSparseUnmanaged(i), ref field2.RefSparseUnmanaged(i), ref field3.RefSparseUnmanaged(i), ref field4.RefSparseUnmanaged(i), ref field5.RefSparseUnmanaged(i), ref field6.RefSparseUnmanaged(i), ref field7.RefSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSparseSharedUnmanaged(i), ref field1.RefSparseSharedUnmanaged(i), ref field2.RefSparseSharedUnmanaged(i), ref field3.RefSparseSharedUnmanaged(i), ref field4.RefSparseSharedUnmanaged(i), ref field5.RefSparseSharedUnmanaged(i), ref field6.RefSparseSharedUnmanaged(i), ref field7.RefSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefManaged(i), ref field1.RefManaged(i), ref field2.RefManaged(i), ref field3.RefManaged(i), ref field4.RefManaged(i), ref field5.RefManaged(i), ref field6.RefManaged(i), ref field7.RefManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSharedManaged(i), ref field1.RefSharedManaged(i), ref field2.RefSharedManaged(i), ref field3.RefSharedManaged(i), ref field4.RefSharedManaged(i), ref field5.RefSharedManaged(i), ref field6.RefSharedManaged(i), ref field7.RefSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSparseManaged(i), ref field1.RefSparseManaged(i), ref field2.RefSparseManaged(i), ref field3.RefSparseManaged(i), ref field4.RefSparseManaged(i), ref field5.RefSparseManaged(i), ref field6.RefSparseManaged(i), ref field7.RefSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSparseSharedManaged(i), ref field1.RefSparseSharedManaged(i), ref field2.RefSparseSharedManaged(i), ref field3.RefSparseSharedManaged(i), ref field4.RefSparseSharedManaged(i), ref field5.RefSparseSharedManaged(i), ref field6.RefSparseSharedManaged(i), ref field7.RefSparseSharedManaged(i));
+        }
     }
 
     /// <summary>
@@ -143,15 +613,93 @@ public static void Each<T0, T1, T2, T3, T4, T5, T6, T7>(Iter it, Ecs.EachPointer
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7);
+        IterationTechnique flags = it.GetIterationTechnique(8);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7])
-            callback((T0*)pointer0, (T1*)pointer1, (T2*)pointer2, (T3*)pointer3, (T4*)pointer4, (T5*)pointer5, (T6*)pointer6, (T7*)pointer7);
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerUnmanaged(i), field1.PointerUnmanaged(i), field2.PointerUnmanaged(i), field3.PointerUnmanaged(i), field4.PointerUnmanaged(i), field5.PointerUnmanaged(i), field6.PointerUnmanaged(i), field7.PointerUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSharedUnmanaged(i), field1.PointerSharedUnmanaged(i), field2.PointerSharedUnmanaged(i), field3.PointerSharedUnmanaged(i), field4.PointerSharedUnmanaged(i), field5.PointerSharedUnmanaged(i), field6.PointerSharedUnmanaged(i), field7.PointerSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSparseUnmanaged(i), field1.PointerSparseUnmanaged(i), field2.PointerSparseUnmanaged(i), field3.PointerSparseUnmanaged(i), field4.PointerSparseUnmanaged(i), field5.PointerSparseUnmanaged(i), field6.PointerSparseUnmanaged(i), field7.PointerSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSparseSharedUnmanaged(i), field1.PointerSparseSharedUnmanaged(i), field2.PointerSparseSharedUnmanaged(i), field3.PointerSparseSharedUnmanaged(i), field4.PointerSparseSharedUnmanaged(i), field5.PointerSparseSharedUnmanaged(i), field6.PointerSparseSharedUnmanaged(i), field7.PointerSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerManaged(i), field1.PointerManaged(i), field2.PointerManaged(i), field3.PointerManaged(i), field4.PointerManaged(i), field5.PointerManaged(i), field6.PointerManaged(i), field7.PointerManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSharedManaged(i), field1.PointerSharedManaged(i), field2.PointerSharedManaged(i), field3.PointerSharedManaged(i), field4.PointerSharedManaged(i), field5.PointerSharedManaged(i), field6.PointerSharedManaged(i), field7.PointerSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSparseManaged(i), field1.PointerSparseManaged(i), field2.PointerSparseManaged(i), field3.PointerSparseManaged(i), field4.PointerSparseManaged(i), field5.PointerSparseManaged(i), field6.PointerSparseManaged(i), field7.PointerSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSparseSharedManaged(i), field1.PointerSparseSharedManaged(i), field2.PointerSparseSharedManaged(i), field3.PointerSparseSharedManaged(i), field4.PointerSparseSharedManaged(i), field5.PointerSparseSharedManaged(i), field6.PointerSparseSharedManaged(i), field7.PointerSparseSharedManaged(i));
+        }
     }
 
     /// <summary>
@@ -164,15 +712,93 @@ public static void Each<T0, T1, T2, T3, T4, T5, T6, T7>(Iter it, Ecs.EachEntityP
     {
         int count = it.Handle->count; Ecs.Assert(it.Handle->count > 0, "No entities returned, use Iter() or Each() without the entity argument instead.");
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7);
+        IterationTechnique flags = it.GetIterationTechnique(8);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7])
-            callback(new Entity(it.Handle->world, it.Handle->entities[i]), (T0*)pointer0, (T1*)pointer1, (T2*)pointer2, (T3*)pointer3, (T4*)pointer4, (T5*)pointer5, (T6*)pointer6, (T7*)pointer7);
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerUnmanaged(i), field1.PointerUnmanaged(i), field2.PointerUnmanaged(i), field3.PointerUnmanaged(i), field4.PointerUnmanaged(i), field5.PointerUnmanaged(i), field6.PointerUnmanaged(i), field7.PointerUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSharedUnmanaged(i), field1.PointerSharedUnmanaged(i), field2.PointerSharedUnmanaged(i), field3.PointerSharedUnmanaged(i), field4.PointerSharedUnmanaged(i), field5.PointerSharedUnmanaged(i), field6.PointerSharedUnmanaged(i), field7.PointerSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseUnmanaged(i), field1.PointerSparseUnmanaged(i), field2.PointerSparseUnmanaged(i), field3.PointerSparseUnmanaged(i), field4.PointerSparseUnmanaged(i), field5.PointerSparseUnmanaged(i), field6.PointerSparseUnmanaged(i), field7.PointerSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseSharedUnmanaged(i), field1.PointerSparseSharedUnmanaged(i), field2.PointerSparseSharedUnmanaged(i), field3.PointerSparseSharedUnmanaged(i), field4.PointerSparseSharedUnmanaged(i), field5.PointerSparseSharedUnmanaged(i), field6.PointerSparseSharedUnmanaged(i), field7.PointerSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerManaged(i), field1.PointerManaged(i), field2.PointerManaged(i), field3.PointerManaged(i), field4.PointerManaged(i), field5.PointerManaged(i), field6.PointerManaged(i), field7.PointerManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSharedManaged(i), field1.PointerSharedManaged(i), field2.PointerSharedManaged(i), field3.PointerSharedManaged(i), field4.PointerSharedManaged(i), field5.PointerSharedManaged(i), field6.PointerSharedManaged(i), field7.PointerSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseManaged(i), field1.PointerSparseManaged(i), field2.PointerSparseManaged(i), field3.PointerSparseManaged(i), field4.PointerSparseManaged(i), field5.PointerSparseManaged(i), field6.PointerSparseManaged(i), field7.PointerSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseSharedManaged(i), field1.PointerSparseSharedManaged(i), field2.PointerSparseSharedManaged(i), field3.PointerSparseSharedManaged(i), field4.PointerSparseSharedManaged(i), field5.PointerSparseSharedManaged(i), field6.PointerSparseSharedManaged(i), field7.PointerSparseSharedManaged(i));
+        }
     }
 
     /// <summary>
@@ -185,15 +811,93 @@ public static void Each<T0, T1, T2, T3, T4, T5, T6, T7>(Iter it, Ecs.EachIterPoi
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7);
+        IterationTechnique flags = it.GetIterationTechnique(8);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7])
-            callback(it, i, (T0*)pointer0, (T1*)pointer1, (T2*)pointer2, (T3*)pointer3, (T4*)pointer4, (T5*)pointer5, (T6*)pointer6, (T7*)pointer7);
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerUnmanaged(i), field1.PointerUnmanaged(i), field2.PointerUnmanaged(i), field3.PointerUnmanaged(i), field4.PointerUnmanaged(i), field5.PointerUnmanaged(i), field6.PointerUnmanaged(i), field7.PointerUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSharedUnmanaged(i), field1.PointerSharedUnmanaged(i), field2.PointerSharedUnmanaged(i), field3.PointerSharedUnmanaged(i), field4.PointerSharedUnmanaged(i), field5.PointerSharedUnmanaged(i), field6.PointerSharedUnmanaged(i), field7.PointerSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSparseUnmanaged(i), field1.PointerSparseUnmanaged(i), field2.PointerSparseUnmanaged(i), field3.PointerSparseUnmanaged(i), field4.PointerSparseUnmanaged(i), field5.PointerSparseUnmanaged(i), field6.PointerSparseUnmanaged(i), field7.PointerSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSparseSharedUnmanaged(i), field1.PointerSparseSharedUnmanaged(i), field2.PointerSparseSharedUnmanaged(i), field3.PointerSparseSharedUnmanaged(i), field4.PointerSparseSharedUnmanaged(i), field5.PointerSparseSharedUnmanaged(i), field6.PointerSparseSharedUnmanaged(i), field7.PointerSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerManaged(i), field1.PointerManaged(i), field2.PointerManaged(i), field3.PointerManaged(i), field4.PointerManaged(i), field5.PointerManaged(i), field6.PointerManaged(i), field7.PointerManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSharedManaged(i), field1.PointerSharedManaged(i), field2.PointerSharedManaged(i), field3.PointerSharedManaged(i), field4.PointerSharedManaged(i), field5.PointerSharedManaged(i), field6.PointerSharedManaged(i), field7.PointerSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSparseManaged(i), field1.PointerSparseManaged(i), field2.PointerSparseManaged(i), field3.PointerSparseManaged(i), field4.PointerSparseManaged(i), field5.PointerSparseManaged(i), field6.PointerSparseManaged(i), field7.PointerSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSparseSharedManaged(i), field1.PointerSparseSharedManaged(i), field2.PointerSparseSharedManaged(i), field3.PointerSparseSharedManaged(i), field4.PointerSparseSharedManaged(i), field5.PointerSparseSharedManaged(i), field6.PointerSparseSharedManaged(i), field7.PointerSparseSharedManaged(i));
+        }
     }
 
     /// <summary>
@@ -206,15 +910,93 @@ public static void Each<T0, T1, T2, T3, T4, T5, T6, T7>(Iter it, delegate*<T0*,
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7);
+        IterationTechnique flags = it.GetIterationTechnique(8);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7])
-            callback((T0*)pointer0, (T1*)pointer1, (T2*)pointer2, (T3*)pointer3, (T4*)pointer4, (T5*)pointer5, (T6*)pointer6, (T7*)pointer7);
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerUnmanaged(i), field1.PointerUnmanaged(i), field2.PointerUnmanaged(i), field3.PointerUnmanaged(i), field4.PointerUnmanaged(i), field5.PointerUnmanaged(i), field6.PointerUnmanaged(i), field7.PointerUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSharedUnmanaged(i), field1.PointerSharedUnmanaged(i), field2.PointerSharedUnmanaged(i), field3.PointerSharedUnmanaged(i), field4.PointerSharedUnmanaged(i), field5.PointerSharedUnmanaged(i), field6.PointerSharedUnmanaged(i), field7.PointerSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSparseUnmanaged(i), field1.PointerSparseUnmanaged(i), field2.PointerSparseUnmanaged(i), field3.PointerSparseUnmanaged(i), field4.PointerSparseUnmanaged(i), field5.PointerSparseUnmanaged(i), field6.PointerSparseUnmanaged(i), field7.PointerSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSparseSharedUnmanaged(i), field1.PointerSparseSharedUnmanaged(i), field2.PointerSparseSharedUnmanaged(i), field3.PointerSparseSharedUnmanaged(i), field4.PointerSparseSharedUnmanaged(i), field5.PointerSparseSharedUnmanaged(i), field6.PointerSparseSharedUnmanaged(i), field7.PointerSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerManaged(i), field1.PointerManaged(i), field2.PointerManaged(i), field3.PointerManaged(i), field4.PointerManaged(i), field5.PointerManaged(i), field6.PointerManaged(i), field7.PointerManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSharedManaged(i), field1.PointerSharedManaged(i), field2.PointerSharedManaged(i), field3.PointerSharedManaged(i), field4.PointerSharedManaged(i), field5.PointerSharedManaged(i), field6.PointerSharedManaged(i), field7.PointerSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSparseManaged(i), field1.PointerSparseManaged(i), field2.PointerSparseManaged(i), field3.PointerSparseManaged(i), field4.PointerSparseManaged(i), field5.PointerSparseManaged(i), field6.PointerSparseManaged(i), field7.PointerSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSparseSharedManaged(i), field1.PointerSparseSharedManaged(i), field2.PointerSparseSharedManaged(i), field3.PointerSparseSharedManaged(i), field4.PointerSparseSharedManaged(i), field5.PointerSparseSharedManaged(i), field6.PointerSparseSharedManaged(i), field7.PointerSparseSharedManaged(i));
+        }
     }
 
     /// <summary>
@@ -227,15 +1009,93 @@ public static void Each<T0, T1, T2, T3, T4, T5, T6, T7>(Iter it, delegate*<Entit
     {
         int count = it.Handle->count; Ecs.Assert(it.Handle->count > 0, "No entities returned, use Iter() or Each() without the entity argument instead.");
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7);
+        IterationTechnique flags = it.GetIterationTechnique(8);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7])
-            callback(new Entity(it.Handle->world, it.Handle->entities[i]), (T0*)pointer0, (T1*)pointer1, (T2*)pointer2, (T3*)pointer3, (T4*)pointer4, (T5*)pointer5, (T6*)pointer6, (T7*)pointer7);
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerUnmanaged(i), field1.PointerUnmanaged(i), field2.PointerUnmanaged(i), field3.PointerUnmanaged(i), field4.PointerUnmanaged(i), field5.PointerUnmanaged(i), field6.PointerUnmanaged(i), field7.PointerUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSharedUnmanaged(i), field1.PointerSharedUnmanaged(i), field2.PointerSharedUnmanaged(i), field3.PointerSharedUnmanaged(i), field4.PointerSharedUnmanaged(i), field5.PointerSharedUnmanaged(i), field6.PointerSharedUnmanaged(i), field7.PointerSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseUnmanaged(i), field1.PointerSparseUnmanaged(i), field2.PointerSparseUnmanaged(i), field3.PointerSparseUnmanaged(i), field4.PointerSparseUnmanaged(i), field5.PointerSparseUnmanaged(i), field6.PointerSparseUnmanaged(i), field7.PointerSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseSharedUnmanaged(i), field1.PointerSparseSharedUnmanaged(i), field2.PointerSparseSharedUnmanaged(i), field3.PointerSparseSharedUnmanaged(i), field4.PointerSparseSharedUnmanaged(i), field5.PointerSparseSharedUnmanaged(i), field6.PointerSparseSharedUnmanaged(i), field7.PointerSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerManaged(i), field1.PointerManaged(i), field2.PointerManaged(i), field3.PointerManaged(i), field4.PointerManaged(i), field5.PointerManaged(i), field6.PointerManaged(i), field7.PointerManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSharedManaged(i), field1.PointerSharedManaged(i), field2.PointerSharedManaged(i), field3.PointerSharedManaged(i), field4.PointerSharedManaged(i), field5.PointerSharedManaged(i), field6.PointerSharedManaged(i), field7.PointerSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseManaged(i), field1.PointerSparseManaged(i), field2.PointerSparseManaged(i), field3.PointerSparseManaged(i), field4.PointerSparseManaged(i), field5.PointerSparseManaged(i), field6.PointerSparseManaged(i), field7.PointerSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseSharedManaged(i), field1.PointerSparseSharedManaged(i), field2.PointerSparseSharedManaged(i), field3.PointerSparseSharedManaged(i), field4.PointerSparseSharedManaged(i), field5.PointerSparseSharedManaged(i), field6.PointerSparseSharedManaged(i), field7.PointerSparseSharedManaged(i));
+        }
     }
 
     /// <summary>
@@ -248,14 +1108,92 @@ public static void Each<T0, T1, T2, T3, T4, T5, T6, T7>(Iter it, delegate*<Iter,
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7);
+        IterationTechnique flags = it.GetIterationTechnique(8);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7])
-            callback(it, i, (T0*)pointer0, (T1*)pointer1, (T2*)pointer2, (T3*)pointer3, (T4*)pointer4, (T5*)pointer5, (T6*)pointer6, (T7*)pointer7);
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerUnmanaged(i), field1.PointerUnmanaged(i), field2.PointerUnmanaged(i), field3.PointerUnmanaged(i), field4.PointerUnmanaged(i), field5.PointerUnmanaged(i), field6.PointerUnmanaged(i), field7.PointerUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSharedUnmanaged(i), field1.PointerSharedUnmanaged(i), field2.PointerSharedUnmanaged(i), field3.PointerSharedUnmanaged(i), field4.PointerSharedUnmanaged(i), field5.PointerSharedUnmanaged(i), field6.PointerSharedUnmanaged(i), field7.PointerSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSparseUnmanaged(i), field1.PointerSparseUnmanaged(i), field2.PointerSparseUnmanaged(i), field3.PointerSparseUnmanaged(i), field4.PointerSparseUnmanaged(i), field5.PointerSparseUnmanaged(i), field6.PointerSparseUnmanaged(i), field7.PointerSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSparseSharedUnmanaged(i), field1.PointerSparseSharedUnmanaged(i), field2.PointerSparseSharedUnmanaged(i), field3.PointerSparseSharedUnmanaged(i), field4.PointerSparseSharedUnmanaged(i), field5.PointerSparseSharedUnmanaged(i), field6.PointerSparseSharedUnmanaged(i), field7.PointerSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerManaged(i), field1.PointerManaged(i), field2.PointerManaged(i), field3.PointerManaged(i), field4.PointerManaged(i), field5.PointerManaged(i), field6.PointerManaged(i), field7.PointerManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSharedManaged(i), field1.PointerSharedManaged(i), field2.PointerSharedManaged(i), field3.PointerSharedManaged(i), field4.PointerSharedManaged(i), field5.PointerSharedManaged(i), field6.PointerSharedManaged(i), field7.PointerSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSparseManaged(i), field1.PointerSparseManaged(i), field2.PointerSparseManaged(i), field3.PointerSparseManaged(i), field4.PointerSparseManaged(i), field5.PointerSparseManaged(i), field6.PointerSparseManaged(i), field7.PointerSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSparseSharedManaged(i), field1.PointerSparseSharedManaged(i), field2.PointerSparseSharedManaged(i), field3.PointerSparseSharedManaged(i), field4.PointerSparseSharedManaged(i), field5.PointerSparseSharedManaged(i), field6.PointerSparseSharedManaged(i), field7.PointerSparseSharedManaged(i));
+        }
     }
 }
\ No newline at end of file
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/Invoker/Each/Iterator/T9.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/Invoker/Each/Iterator/T9.g.cs
index 6f91c90c..1698a279 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/Invoker/Each/Iterator/T9.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/Invoker/Each/Iterator/T9.g.cs
@@ -1,5 +1,7 @@
 // Each/Iterator/T9.g.cs
 // File was auto-generated by /_/src/Flecs.NET.Codegen/Generators/Invoker.cs
+using System;
+using System.Runtime.CompilerServices;
 using Flecs.NET.Utilities;
 using static Flecs.NET.Bindings.flecs;
 
@@ -17,15 +19,93 @@ public static void Each<T0, T1, T2, T3, T4, T5, T6, T7, T8>(Iter it, Ecs.EachRef
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8);
+        IterationTechnique flags = it.GetIterationTechnique(9);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8])
-            callback(ref Managed.GetTypeRef<T0>(pointer0), ref Managed.GetTypeRef<T1>(pointer1), ref Managed.GetTypeRef<T2>(pointer2), ref Managed.GetTypeRef<T3>(pointer3), ref Managed.GetTypeRef<T4>(pointer4), ref Managed.GetTypeRef<T5>(pointer5), ref Managed.GetTypeRef<T6>(pointer6), ref Managed.GetTypeRef<T7>(pointer7), ref Managed.GetTypeRef<T8>(pointer8));
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefUnmanaged(i), ref field1.RefUnmanaged(i), ref field2.RefUnmanaged(i), ref field3.RefUnmanaged(i), ref field4.RefUnmanaged(i), ref field5.RefUnmanaged(i), ref field6.RefUnmanaged(i), ref field7.RefUnmanaged(i), ref field8.RefUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSharedUnmanaged(i), ref field1.RefSharedUnmanaged(i), ref field2.RefSharedUnmanaged(i), ref field3.RefSharedUnmanaged(i), ref field4.RefSharedUnmanaged(i), ref field5.RefSharedUnmanaged(i), ref field6.RefSharedUnmanaged(i), ref field7.RefSharedUnmanaged(i), ref field8.RefSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSparseUnmanaged(i), ref field1.RefSparseUnmanaged(i), ref field2.RefSparseUnmanaged(i), ref field3.RefSparseUnmanaged(i), ref field4.RefSparseUnmanaged(i), ref field5.RefSparseUnmanaged(i), ref field6.RefSparseUnmanaged(i), ref field7.RefSparseUnmanaged(i), ref field8.RefSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSparseSharedUnmanaged(i), ref field1.RefSparseSharedUnmanaged(i), ref field2.RefSparseSharedUnmanaged(i), ref field3.RefSparseSharedUnmanaged(i), ref field4.RefSparseSharedUnmanaged(i), ref field5.RefSparseSharedUnmanaged(i), ref field6.RefSparseSharedUnmanaged(i), ref field7.RefSparseSharedUnmanaged(i), ref field8.RefSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefManaged(i), ref field1.RefManaged(i), ref field2.RefManaged(i), ref field3.RefManaged(i), ref field4.RefManaged(i), ref field5.RefManaged(i), ref field6.RefManaged(i), ref field7.RefManaged(i), ref field8.RefManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSharedManaged(i), ref field1.RefSharedManaged(i), ref field2.RefSharedManaged(i), ref field3.RefSharedManaged(i), ref field4.RefSharedManaged(i), ref field5.RefSharedManaged(i), ref field6.RefSharedManaged(i), ref field7.RefSharedManaged(i), ref field8.RefSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSparseManaged(i), ref field1.RefSparseManaged(i), ref field2.RefSparseManaged(i), ref field3.RefSparseManaged(i), ref field4.RefSparseManaged(i), ref field5.RefSparseManaged(i), ref field6.RefSparseManaged(i), ref field7.RefSparseManaged(i), ref field8.RefSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSparseSharedManaged(i), ref field1.RefSparseSharedManaged(i), ref field2.RefSparseSharedManaged(i), ref field3.RefSparseSharedManaged(i), ref field4.RefSparseSharedManaged(i), ref field5.RefSparseSharedManaged(i), ref field6.RefSparseSharedManaged(i), ref field7.RefSparseSharedManaged(i), ref field8.RefSparseSharedManaged(i));
+        }
     }
 
     /// <summary>
@@ -38,15 +118,93 @@ public static void Each<T0, T1, T2, T3, T4, T5, T6, T7, T8>(Iter it, Ecs.EachEnt
     {
         int count = it.Handle->count; Ecs.Assert(it.Handle->count > 0, "No entities returned, use Iter() or Each() without the entity argument instead.");
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8);
+        IterationTechnique flags = it.GetIterationTechnique(9);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8])
-            callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref Managed.GetTypeRef<T0>(pointer0), ref Managed.GetTypeRef<T1>(pointer1), ref Managed.GetTypeRef<T2>(pointer2), ref Managed.GetTypeRef<T3>(pointer3), ref Managed.GetTypeRef<T4>(pointer4), ref Managed.GetTypeRef<T5>(pointer5), ref Managed.GetTypeRef<T6>(pointer6), ref Managed.GetTypeRef<T7>(pointer7), ref Managed.GetTypeRef<T8>(pointer8));
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefUnmanaged(i), ref field1.RefUnmanaged(i), ref field2.RefUnmanaged(i), ref field3.RefUnmanaged(i), ref field4.RefUnmanaged(i), ref field5.RefUnmanaged(i), ref field6.RefUnmanaged(i), ref field7.RefUnmanaged(i), ref field8.RefUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSharedUnmanaged(i), ref field1.RefSharedUnmanaged(i), ref field2.RefSharedUnmanaged(i), ref field3.RefSharedUnmanaged(i), ref field4.RefSharedUnmanaged(i), ref field5.RefSharedUnmanaged(i), ref field6.RefSharedUnmanaged(i), ref field7.RefSharedUnmanaged(i), ref field8.RefSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseUnmanaged(i), ref field1.RefSparseUnmanaged(i), ref field2.RefSparseUnmanaged(i), ref field3.RefSparseUnmanaged(i), ref field4.RefSparseUnmanaged(i), ref field5.RefSparseUnmanaged(i), ref field6.RefSparseUnmanaged(i), ref field7.RefSparseUnmanaged(i), ref field8.RefSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseSharedUnmanaged(i), ref field1.RefSparseSharedUnmanaged(i), ref field2.RefSparseSharedUnmanaged(i), ref field3.RefSparseSharedUnmanaged(i), ref field4.RefSparseSharedUnmanaged(i), ref field5.RefSparseSharedUnmanaged(i), ref field6.RefSparseSharedUnmanaged(i), ref field7.RefSparseSharedUnmanaged(i), ref field8.RefSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefManaged(i), ref field1.RefManaged(i), ref field2.RefManaged(i), ref field3.RefManaged(i), ref field4.RefManaged(i), ref field5.RefManaged(i), ref field6.RefManaged(i), ref field7.RefManaged(i), ref field8.RefManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSharedManaged(i), ref field1.RefSharedManaged(i), ref field2.RefSharedManaged(i), ref field3.RefSharedManaged(i), ref field4.RefSharedManaged(i), ref field5.RefSharedManaged(i), ref field6.RefSharedManaged(i), ref field7.RefSharedManaged(i), ref field8.RefSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseManaged(i), ref field1.RefSparseManaged(i), ref field2.RefSparseManaged(i), ref field3.RefSparseManaged(i), ref field4.RefSparseManaged(i), ref field5.RefSparseManaged(i), ref field6.RefSparseManaged(i), ref field7.RefSparseManaged(i), ref field8.RefSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseSharedManaged(i), ref field1.RefSparseSharedManaged(i), ref field2.RefSparseSharedManaged(i), ref field3.RefSparseSharedManaged(i), ref field4.RefSparseSharedManaged(i), ref field5.RefSparseSharedManaged(i), ref field6.RefSparseSharedManaged(i), ref field7.RefSparseSharedManaged(i), ref field8.RefSparseSharedManaged(i));
+        }
     }
 
     /// <summary>
@@ -59,15 +217,93 @@ public static void Each<T0, T1, T2, T3, T4, T5, T6, T7, T8>(Iter it, Ecs.EachIte
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8);
+        IterationTechnique flags = it.GetIterationTechnique(9);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8])
-            callback(it, i, ref Managed.GetTypeRef<T0>(pointer0), ref Managed.GetTypeRef<T1>(pointer1), ref Managed.GetTypeRef<T2>(pointer2), ref Managed.GetTypeRef<T3>(pointer3), ref Managed.GetTypeRef<T4>(pointer4), ref Managed.GetTypeRef<T5>(pointer5), ref Managed.GetTypeRef<T6>(pointer6), ref Managed.GetTypeRef<T7>(pointer7), ref Managed.GetTypeRef<T8>(pointer8));
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefUnmanaged(i), ref field1.RefUnmanaged(i), ref field2.RefUnmanaged(i), ref field3.RefUnmanaged(i), ref field4.RefUnmanaged(i), ref field5.RefUnmanaged(i), ref field6.RefUnmanaged(i), ref field7.RefUnmanaged(i), ref field8.RefUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSharedUnmanaged(i), ref field1.RefSharedUnmanaged(i), ref field2.RefSharedUnmanaged(i), ref field3.RefSharedUnmanaged(i), ref field4.RefSharedUnmanaged(i), ref field5.RefSharedUnmanaged(i), ref field6.RefSharedUnmanaged(i), ref field7.RefSharedUnmanaged(i), ref field8.RefSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSparseUnmanaged(i), ref field1.RefSparseUnmanaged(i), ref field2.RefSparseUnmanaged(i), ref field3.RefSparseUnmanaged(i), ref field4.RefSparseUnmanaged(i), ref field5.RefSparseUnmanaged(i), ref field6.RefSparseUnmanaged(i), ref field7.RefSparseUnmanaged(i), ref field8.RefSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSparseSharedUnmanaged(i), ref field1.RefSparseSharedUnmanaged(i), ref field2.RefSparseSharedUnmanaged(i), ref field3.RefSparseSharedUnmanaged(i), ref field4.RefSparseSharedUnmanaged(i), ref field5.RefSparseSharedUnmanaged(i), ref field6.RefSparseSharedUnmanaged(i), ref field7.RefSparseSharedUnmanaged(i), ref field8.RefSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefManaged(i), ref field1.RefManaged(i), ref field2.RefManaged(i), ref field3.RefManaged(i), ref field4.RefManaged(i), ref field5.RefManaged(i), ref field6.RefManaged(i), ref field7.RefManaged(i), ref field8.RefManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSharedManaged(i), ref field1.RefSharedManaged(i), ref field2.RefSharedManaged(i), ref field3.RefSharedManaged(i), ref field4.RefSharedManaged(i), ref field5.RefSharedManaged(i), ref field6.RefSharedManaged(i), ref field7.RefSharedManaged(i), ref field8.RefSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSparseManaged(i), ref field1.RefSparseManaged(i), ref field2.RefSparseManaged(i), ref field3.RefSparseManaged(i), ref field4.RefSparseManaged(i), ref field5.RefSparseManaged(i), ref field6.RefSparseManaged(i), ref field7.RefSparseManaged(i), ref field8.RefSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSparseSharedManaged(i), ref field1.RefSparseSharedManaged(i), ref field2.RefSparseSharedManaged(i), ref field3.RefSparseSharedManaged(i), ref field4.RefSparseSharedManaged(i), ref field5.RefSparseSharedManaged(i), ref field6.RefSparseSharedManaged(i), ref field7.RefSparseSharedManaged(i), ref field8.RefSparseSharedManaged(i));
+        }
     }
 
     /// <summary>
@@ -80,15 +316,93 @@ public static void Each<T0, T1, T2, T3, T4, T5, T6, T7, T8>(Iter it, delegate*<r
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8);
+        IterationTechnique flags = it.GetIterationTechnique(9);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8])
-            callback(ref Managed.GetTypeRef<T0>(pointer0), ref Managed.GetTypeRef<T1>(pointer1), ref Managed.GetTypeRef<T2>(pointer2), ref Managed.GetTypeRef<T3>(pointer3), ref Managed.GetTypeRef<T4>(pointer4), ref Managed.GetTypeRef<T5>(pointer5), ref Managed.GetTypeRef<T6>(pointer6), ref Managed.GetTypeRef<T7>(pointer7), ref Managed.GetTypeRef<T8>(pointer8));
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefUnmanaged(i), ref field1.RefUnmanaged(i), ref field2.RefUnmanaged(i), ref field3.RefUnmanaged(i), ref field4.RefUnmanaged(i), ref field5.RefUnmanaged(i), ref field6.RefUnmanaged(i), ref field7.RefUnmanaged(i), ref field8.RefUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSharedUnmanaged(i), ref field1.RefSharedUnmanaged(i), ref field2.RefSharedUnmanaged(i), ref field3.RefSharedUnmanaged(i), ref field4.RefSharedUnmanaged(i), ref field5.RefSharedUnmanaged(i), ref field6.RefSharedUnmanaged(i), ref field7.RefSharedUnmanaged(i), ref field8.RefSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSparseUnmanaged(i), ref field1.RefSparseUnmanaged(i), ref field2.RefSparseUnmanaged(i), ref field3.RefSparseUnmanaged(i), ref field4.RefSparseUnmanaged(i), ref field5.RefSparseUnmanaged(i), ref field6.RefSparseUnmanaged(i), ref field7.RefSparseUnmanaged(i), ref field8.RefSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSparseSharedUnmanaged(i), ref field1.RefSparseSharedUnmanaged(i), ref field2.RefSparseSharedUnmanaged(i), ref field3.RefSparseSharedUnmanaged(i), ref field4.RefSparseSharedUnmanaged(i), ref field5.RefSparseSharedUnmanaged(i), ref field6.RefSparseSharedUnmanaged(i), ref field7.RefSparseSharedUnmanaged(i), ref field8.RefSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefManaged(i), ref field1.RefManaged(i), ref field2.RefManaged(i), ref field3.RefManaged(i), ref field4.RefManaged(i), ref field5.RefManaged(i), ref field6.RefManaged(i), ref field7.RefManaged(i), ref field8.RefManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSharedManaged(i), ref field1.RefSharedManaged(i), ref field2.RefSharedManaged(i), ref field3.RefSharedManaged(i), ref field4.RefSharedManaged(i), ref field5.RefSharedManaged(i), ref field6.RefSharedManaged(i), ref field7.RefSharedManaged(i), ref field8.RefSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSparseManaged(i), ref field1.RefSparseManaged(i), ref field2.RefSparseManaged(i), ref field3.RefSparseManaged(i), ref field4.RefSparseManaged(i), ref field5.RefSparseManaged(i), ref field6.RefSparseManaged(i), ref field7.RefSparseManaged(i), ref field8.RefSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+                callback(ref field0.RefSparseSharedManaged(i), ref field1.RefSparseSharedManaged(i), ref field2.RefSparseSharedManaged(i), ref field3.RefSparseSharedManaged(i), ref field4.RefSparseSharedManaged(i), ref field5.RefSparseSharedManaged(i), ref field6.RefSparseSharedManaged(i), ref field7.RefSparseSharedManaged(i), ref field8.RefSparseSharedManaged(i));
+        }
     }
 
     /// <summary>
@@ -101,15 +415,93 @@ public static void Each<T0, T1, T2, T3, T4, T5, T6, T7, T8>(Iter it, delegate*<E
     {
         int count = it.Handle->count; Ecs.Assert(it.Handle->count > 0, "No entities returned, use Iter() or Each() without the entity argument instead.");
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8);
+        IterationTechnique flags = it.GetIterationTechnique(9);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8])
-            callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref Managed.GetTypeRef<T0>(pointer0), ref Managed.GetTypeRef<T1>(pointer1), ref Managed.GetTypeRef<T2>(pointer2), ref Managed.GetTypeRef<T3>(pointer3), ref Managed.GetTypeRef<T4>(pointer4), ref Managed.GetTypeRef<T5>(pointer5), ref Managed.GetTypeRef<T6>(pointer6), ref Managed.GetTypeRef<T7>(pointer7), ref Managed.GetTypeRef<T8>(pointer8));
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefUnmanaged(i), ref field1.RefUnmanaged(i), ref field2.RefUnmanaged(i), ref field3.RefUnmanaged(i), ref field4.RefUnmanaged(i), ref field5.RefUnmanaged(i), ref field6.RefUnmanaged(i), ref field7.RefUnmanaged(i), ref field8.RefUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSharedUnmanaged(i), ref field1.RefSharedUnmanaged(i), ref field2.RefSharedUnmanaged(i), ref field3.RefSharedUnmanaged(i), ref field4.RefSharedUnmanaged(i), ref field5.RefSharedUnmanaged(i), ref field6.RefSharedUnmanaged(i), ref field7.RefSharedUnmanaged(i), ref field8.RefSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseUnmanaged(i), ref field1.RefSparseUnmanaged(i), ref field2.RefSparseUnmanaged(i), ref field3.RefSparseUnmanaged(i), ref field4.RefSparseUnmanaged(i), ref field5.RefSparseUnmanaged(i), ref field6.RefSparseUnmanaged(i), ref field7.RefSparseUnmanaged(i), ref field8.RefSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseSharedUnmanaged(i), ref field1.RefSparseSharedUnmanaged(i), ref field2.RefSparseSharedUnmanaged(i), ref field3.RefSparseSharedUnmanaged(i), ref field4.RefSparseSharedUnmanaged(i), ref field5.RefSparseSharedUnmanaged(i), ref field6.RefSparseSharedUnmanaged(i), ref field7.RefSparseSharedUnmanaged(i), ref field8.RefSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefManaged(i), ref field1.RefManaged(i), ref field2.RefManaged(i), ref field3.RefManaged(i), ref field4.RefManaged(i), ref field5.RefManaged(i), ref field6.RefManaged(i), ref field7.RefManaged(i), ref field8.RefManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSharedManaged(i), ref field1.RefSharedManaged(i), ref field2.RefSharedManaged(i), ref field3.RefSharedManaged(i), ref field4.RefSharedManaged(i), ref field5.RefSharedManaged(i), ref field6.RefSharedManaged(i), ref field7.RefSharedManaged(i), ref field8.RefSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseManaged(i), ref field1.RefSparseManaged(i), ref field2.RefSparseManaged(i), ref field3.RefSparseManaged(i), ref field4.RefSparseManaged(i), ref field5.RefSparseManaged(i), ref field6.RefSparseManaged(i), ref field7.RefSparseManaged(i), ref field8.RefSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseSharedManaged(i), ref field1.RefSparseSharedManaged(i), ref field2.RefSparseSharedManaged(i), ref field3.RefSparseSharedManaged(i), ref field4.RefSparseSharedManaged(i), ref field5.RefSparseSharedManaged(i), ref field6.RefSparseSharedManaged(i), ref field7.RefSparseSharedManaged(i), ref field8.RefSparseSharedManaged(i));
+        }
     }
 
     /// <summary>
@@ -122,15 +514,93 @@ public static void Each<T0, T1, T2, T3, T4, T5, T6, T7, T8>(Iter it, delegate*<I
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8);
+        IterationTechnique flags = it.GetIterationTechnique(9);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8])
-            callback(it, i, ref Managed.GetTypeRef<T0>(pointer0), ref Managed.GetTypeRef<T1>(pointer1), ref Managed.GetTypeRef<T2>(pointer2), ref Managed.GetTypeRef<T3>(pointer3), ref Managed.GetTypeRef<T4>(pointer4), ref Managed.GetTypeRef<T5>(pointer5), ref Managed.GetTypeRef<T6>(pointer6), ref Managed.GetTypeRef<T7>(pointer7), ref Managed.GetTypeRef<T8>(pointer8));
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefUnmanaged(i), ref field1.RefUnmanaged(i), ref field2.RefUnmanaged(i), ref field3.RefUnmanaged(i), ref field4.RefUnmanaged(i), ref field5.RefUnmanaged(i), ref field6.RefUnmanaged(i), ref field7.RefUnmanaged(i), ref field8.RefUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSharedUnmanaged(i), ref field1.RefSharedUnmanaged(i), ref field2.RefSharedUnmanaged(i), ref field3.RefSharedUnmanaged(i), ref field4.RefSharedUnmanaged(i), ref field5.RefSharedUnmanaged(i), ref field6.RefSharedUnmanaged(i), ref field7.RefSharedUnmanaged(i), ref field8.RefSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSparseUnmanaged(i), ref field1.RefSparseUnmanaged(i), ref field2.RefSparseUnmanaged(i), ref field3.RefSparseUnmanaged(i), ref field4.RefSparseUnmanaged(i), ref field5.RefSparseUnmanaged(i), ref field6.RefSparseUnmanaged(i), ref field7.RefSparseUnmanaged(i), ref field8.RefSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSparseSharedUnmanaged(i), ref field1.RefSparseSharedUnmanaged(i), ref field2.RefSparseSharedUnmanaged(i), ref field3.RefSparseSharedUnmanaged(i), ref field4.RefSparseSharedUnmanaged(i), ref field5.RefSparseSharedUnmanaged(i), ref field6.RefSparseSharedUnmanaged(i), ref field7.RefSparseSharedUnmanaged(i), ref field8.RefSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefManaged(i), ref field1.RefManaged(i), ref field2.RefManaged(i), ref field3.RefManaged(i), ref field4.RefManaged(i), ref field5.RefManaged(i), ref field6.RefManaged(i), ref field7.RefManaged(i), ref field8.RefManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSharedManaged(i), ref field1.RefSharedManaged(i), ref field2.RefSharedManaged(i), ref field3.RefSharedManaged(i), ref field4.RefSharedManaged(i), ref field5.RefSharedManaged(i), ref field6.RefSharedManaged(i), ref field7.RefSharedManaged(i), ref field8.RefSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSparseManaged(i), ref field1.RefSparseManaged(i), ref field2.RefSparseManaged(i), ref field3.RefSparseManaged(i), ref field4.RefSparseManaged(i), ref field5.RefSparseManaged(i), ref field6.RefSparseManaged(i), ref field7.RefSparseManaged(i), ref field8.RefSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, ref field0.RefSparseSharedManaged(i), ref field1.RefSparseSharedManaged(i), ref field2.RefSparseSharedManaged(i), ref field3.RefSparseSharedManaged(i), ref field4.RefSparseSharedManaged(i), ref field5.RefSparseSharedManaged(i), ref field6.RefSparseSharedManaged(i), ref field7.RefSparseSharedManaged(i), ref field8.RefSparseSharedManaged(i));
+        }
     }
 
     /// <summary>
@@ -143,15 +613,93 @@ public static void Each<T0, T1, T2, T3, T4, T5, T6, T7, T8>(Iter it, Ecs.EachPoi
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8);
+        IterationTechnique flags = it.GetIterationTechnique(9);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8])
-            callback((T0*)pointer0, (T1*)pointer1, (T2*)pointer2, (T3*)pointer3, (T4*)pointer4, (T5*)pointer5, (T6*)pointer6, (T7*)pointer7, (T8*)pointer8);
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerUnmanaged(i), field1.PointerUnmanaged(i), field2.PointerUnmanaged(i), field3.PointerUnmanaged(i), field4.PointerUnmanaged(i), field5.PointerUnmanaged(i), field6.PointerUnmanaged(i), field7.PointerUnmanaged(i), field8.PointerUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSharedUnmanaged(i), field1.PointerSharedUnmanaged(i), field2.PointerSharedUnmanaged(i), field3.PointerSharedUnmanaged(i), field4.PointerSharedUnmanaged(i), field5.PointerSharedUnmanaged(i), field6.PointerSharedUnmanaged(i), field7.PointerSharedUnmanaged(i), field8.PointerSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSparseUnmanaged(i), field1.PointerSparseUnmanaged(i), field2.PointerSparseUnmanaged(i), field3.PointerSparseUnmanaged(i), field4.PointerSparseUnmanaged(i), field5.PointerSparseUnmanaged(i), field6.PointerSparseUnmanaged(i), field7.PointerSparseUnmanaged(i), field8.PointerSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSparseSharedUnmanaged(i), field1.PointerSparseSharedUnmanaged(i), field2.PointerSparseSharedUnmanaged(i), field3.PointerSparseSharedUnmanaged(i), field4.PointerSparseSharedUnmanaged(i), field5.PointerSparseSharedUnmanaged(i), field6.PointerSparseSharedUnmanaged(i), field7.PointerSparseSharedUnmanaged(i), field8.PointerSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerManaged(i), field1.PointerManaged(i), field2.PointerManaged(i), field3.PointerManaged(i), field4.PointerManaged(i), field5.PointerManaged(i), field6.PointerManaged(i), field7.PointerManaged(i), field8.PointerManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSharedManaged(i), field1.PointerSharedManaged(i), field2.PointerSharedManaged(i), field3.PointerSharedManaged(i), field4.PointerSharedManaged(i), field5.PointerSharedManaged(i), field6.PointerSharedManaged(i), field7.PointerSharedManaged(i), field8.PointerSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSparseManaged(i), field1.PointerSparseManaged(i), field2.PointerSparseManaged(i), field3.PointerSparseManaged(i), field4.PointerSparseManaged(i), field5.PointerSparseManaged(i), field6.PointerSparseManaged(i), field7.PointerSparseManaged(i), field8.PointerSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSparseSharedManaged(i), field1.PointerSparseSharedManaged(i), field2.PointerSparseSharedManaged(i), field3.PointerSparseSharedManaged(i), field4.PointerSparseSharedManaged(i), field5.PointerSparseSharedManaged(i), field6.PointerSparseSharedManaged(i), field7.PointerSparseSharedManaged(i), field8.PointerSparseSharedManaged(i));
+        }
     }
 
     /// <summary>
@@ -164,15 +712,93 @@ public static void Each<T0, T1, T2, T3, T4, T5, T6, T7, T8>(Iter it, Ecs.EachEnt
     {
         int count = it.Handle->count; Ecs.Assert(it.Handle->count > 0, "No entities returned, use Iter() or Each() without the entity argument instead.");
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8);
+        IterationTechnique flags = it.GetIterationTechnique(9);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8])
-            callback(new Entity(it.Handle->world, it.Handle->entities[i]), (T0*)pointer0, (T1*)pointer1, (T2*)pointer2, (T3*)pointer3, (T4*)pointer4, (T5*)pointer5, (T6*)pointer6, (T7*)pointer7, (T8*)pointer8);
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerUnmanaged(i), field1.PointerUnmanaged(i), field2.PointerUnmanaged(i), field3.PointerUnmanaged(i), field4.PointerUnmanaged(i), field5.PointerUnmanaged(i), field6.PointerUnmanaged(i), field7.PointerUnmanaged(i), field8.PointerUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSharedUnmanaged(i), field1.PointerSharedUnmanaged(i), field2.PointerSharedUnmanaged(i), field3.PointerSharedUnmanaged(i), field4.PointerSharedUnmanaged(i), field5.PointerSharedUnmanaged(i), field6.PointerSharedUnmanaged(i), field7.PointerSharedUnmanaged(i), field8.PointerSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseUnmanaged(i), field1.PointerSparseUnmanaged(i), field2.PointerSparseUnmanaged(i), field3.PointerSparseUnmanaged(i), field4.PointerSparseUnmanaged(i), field5.PointerSparseUnmanaged(i), field6.PointerSparseUnmanaged(i), field7.PointerSparseUnmanaged(i), field8.PointerSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseSharedUnmanaged(i), field1.PointerSparseSharedUnmanaged(i), field2.PointerSparseSharedUnmanaged(i), field3.PointerSparseSharedUnmanaged(i), field4.PointerSparseSharedUnmanaged(i), field5.PointerSparseSharedUnmanaged(i), field6.PointerSparseSharedUnmanaged(i), field7.PointerSparseSharedUnmanaged(i), field8.PointerSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerManaged(i), field1.PointerManaged(i), field2.PointerManaged(i), field3.PointerManaged(i), field4.PointerManaged(i), field5.PointerManaged(i), field6.PointerManaged(i), field7.PointerManaged(i), field8.PointerManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSharedManaged(i), field1.PointerSharedManaged(i), field2.PointerSharedManaged(i), field3.PointerSharedManaged(i), field4.PointerSharedManaged(i), field5.PointerSharedManaged(i), field6.PointerSharedManaged(i), field7.PointerSharedManaged(i), field8.PointerSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseManaged(i), field1.PointerSparseManaged(i), field2.PointerSparseManaged(i), field3.PointerSparseManaged(i), field4.PointerSparseManaged(i), field5.PointerSparseManaged(i), field6.PointerSparseManaged(i), field7.PointerSparseManaged(i), field8.PointerSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseSharedManaged(i), field1.PointerSparseSharedManaged(i), field2.PointerSparseSharedManaged(i), field3.PointerSparseSharedManaged(i), field4.PointerSparseSharedManaged(i), field5.PointerSparseSharedManaged(i), field6.PointerSparseSharedManaged(i), field7.PointerSparseSharedManaged(i), field8.PointerSparseSharedManaged(i));
+        }
     }
 
     /// <summary>
@@ -185,15 +811,93 @@ public static void Each<T0, T1, T2, T3, T4, T5, T6, T7, T8>(Iter it, Ecs.EachIte
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8);
+        IterationTechnique flags = it.GetIterationTechnique(9);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8])
-            callback(it, i, (T0*)pointer0, (T1*)pointer1, (T2*)pointer2, (T3*)pointer3, (T4*)pointer4, (T5*)pointer5, (T6*)pointer6, (T7*)pointer7, (T8*)pointer8);
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerUnmanaged(i), field1.PointerUnmanaged(i), field2.PointerUnmanaged(i), field3.PointerUnmanaged(i), field4.PointerUnmanaged(i), field5.PointerUnmanaged(i), field6.PointerUnmanaged(i), field7.PointerUnmanaged(i), field8.PointerUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSharedUnmanaged(i), field1.PointerSharedUnmanaged(i), field2.PointerSharedUnmanaged(i), field3.PointerSharedUnmanaged(i), field4.PointerSharedUnmanaged(i), field5.PointerSharedUnmanaged(i), field6.PointerSharedUnmanaged(i), field7.PointerSharedUnmanaged(i), field8.PointerSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSparseUnmanaged(i), field1.PointerSparseUnmanaged(i), field2.PointerSparseUnmanaged(i), field3.PointerSparseUnmanaged(i), field4.PointerSparseUnmanaged(i), field5.PointerSparseUnmanaged(i), field6.PointerSparseUnmanaged(i), field7.PointerSparseUnmanaged(i), field8.PointerSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSparseSharedUnmanaged(i), field1.PointerSparseSharedUnmanaged(i), field2.PointerSparseSharedUnmanaged(i), field3.PointerSparseSharedUnmanaged(i), field4.PointerSparseSharedUnmanaged(i), field5.PointerSparseSharedUnmanaged(i), field6.PointerSparseSharedUnmanaged(i), field7.PointerSparseSharedUnmanaged(i), field8.PointerSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerManaged(i), field1.PointerManaged(i), field2.PointerManaged(i), field3.PointerManaged(i), field4.PointerManaged(i), field5.PointerManaged(i), field6.PointerManaged(i), field7.PointerManaged(i), field8.PointerManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSharedManaged(i), field1.PointerSharedManaged(i), field2.PointerSharedManaged(i), field3.PointerSharedManaged(i), field4.PointerSharedManaged(i), field5.PointerSharedManaged(i), field6.PointerSharedManaged(i), field7.PointerSharedManaged(i), field8.PointerSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSparseManaged(i), field1.PointerSparseManaged(i), field2.PointerSparseManaged(i), field3.PointerSparseManaged(i), field4.PointerSparseManaged(i), field5.PointerSparseManaged(i), field6.PointerSparseManaged(i), field7.PointerSparseManaged(i), field8.PointerSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSparseSharedManaged(i), field1.PointerSparseSharedManaged(i), field2.PointerSparseSharedManaged(i), field3.PointerSparseSharedManaged(i), field4.PointerSparseSharedManaged(i), field5.PointerSparseSharedManaged(i), field6.PointerSparseSharedManaged(i), field7.PointerSparseSharedManaged(i), field8.PointerSparseSharedManaged(i));
+        }
     }
 
     /// <summary>
@@ -206,15 +910,93 @@ public static void Each<T0, T1, T2, T3, T4, T5, T6, T7, T8>(Iter it, delegate*<T
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8);
+        IterationTechnique flags = it.GetIterationTechnique(9);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8])
-            callback((T0*)pointer0, (T1*)pointer1, (T2*)pointer2, (T3*)pointer3, (T4*)pointer4, (T5*)pointer5, (T6*)pointer6, (T7*)pointer7, (T8*)pointer8);
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerUnmanaged(i), field1.PointerUnmanaged(i), field2.PointerUnmanaged(i), field3.PointerUnmanaged(i), field4.PointerUnmanaged(i), field5.PointerUnmanaged(i), field6.PointerUnmanaged(i), field7.PointerUnmanaged(i), field8.PointerUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSharedUnmanaged(i), field1.PointerSharedUnmanaged(i), field2.PointerSharedUnmanaged(i), field3.PointerSharedUnmanaged(i), field4.PointerSharedUnmanaged(i), field5.PointerSharedUnmanaged(i), field6.PointerSharedUnmanaged(i), field7.PointerSharedUnmanaged(i), field8.PointerSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSparseUnmanaged(i), field1.PointerSparseUnmanaged(i), field2.PointerSparseUnmanaged(i), field3.PointerSparseUnmanaged(i), field4.PointerSparseUnmanaged(i), field5.PointerSparseUnmanaged(i), field6.PointerSparseUnmanaged(i), field7.PointerSparseUnmanaged(i), field8.PointerSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSparseSharedUnmanaged(i), field1.PointerSparseSharedUnmanaged(i), field2.PointerSparseSharedUnmanaged(i), field3.PointerSparseSharedUnmanaged(i), field4.PointerSparseSharedUnmanaged(i), field5.PointerSparseSharedUnmanaged(i), field6.PointerSparseSharedUnmanaged(i), field7.PointerSparseSharedUnmanaged(i), field8.PointerSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerManaged(i), field1.PointerManaged(i), field2.PointerManaged(i), field3.PointerManaged(i), field4.PointerManaged(i), field5.PointerManaged(i), field6.PointerManaged(i), field7.PointerManaged(i), field8.PointerManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSharedManaged(i), field1.PointerSharedManaged(i), field2.PointerSharedManaged(i), field3.PointerSharedManaged(i), field4.PointerSharedManaged(i), field5.PointerSharedManaged(i), field6.PointerSharedManaged(i), field7.PointerSharedManaged(i), field8.PointerSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSparseManaged(i), field1.PointerSparseManaged(i), field2.PointerSparseManaged(i), field3.PointerSparseManaged(i), field4.PointerSparseManaged(i), field5.PointerSparseManaged(i), field6.PointerSparseManaged(i), field7.PointerSparseManaged(i), field8.PointerSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+                callback(field0.PointerSparseSharedManaged(i), field1.PointerSparseSharedManaged(i), field2.PointerSparseSharedManaged(i), field3.PointerSparseSharedManaged(i), field4.PointerSparseSharedManaged(i), field5.PointerSparseSharedManaged(i), field6.PointerSparseSharedManaged(i), field7.PointerSparseSharedManaged(i), field8.PointerSparseSharedManaged(i));
+        }
     }
 
     /// <summary>
@@ -227,15 +1009,93 @@ public static void Each<T0, T1, T2, T3, T4, T5, T6, T7, T8>(Iter it, delegate*<E
     {
         int count = it.Handle->count; Ecs.Assert(it.Handle->count > 0, "No entities returned, use Iter() or Each() without the entity argument instead.");
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8);
+        IterationTechnique flags = it.GetIterationTechnique(9);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8])
-            callback(new Entity(it.Handle->world, it.Handle->entities[i]), (T0*)pointer0, (T1*)pointer1, (T2*)pointer2, (T3*)pointer3, (T4*)pointer4, (T5*)pointer5, (T6*)pointer6, (T7*)pointer7, (T8*)pointer8);
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerUnmanaged(i), field1.PointerUnmanaged(i), field2.PointerUnmanaged(i), field3.PointerUnmanaged(i), field4.PointerUnmanaged(i), field5.PointerUnmanaged(i), field6.PointerUnmanaged(i), field7.PointerUnmanaged(i), field8.PointerUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSharedUnmanaged(i), field1.PointerSharedUnmanaged(i), field2.PointerSharedUnmanaged(i), field3.PointerSharedUnmanaged(i), field4.PointerSharedUnmanaged(i), field5.PointerSharedUnmanaged(i), field6.PointerSharedUnmanaged(i), field7.PointerSharedUnmanaged(i), field8.PointerSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseUnmanaged(i), field1.PointerSparseUnmanaged(i), field2.PointerSparseUnmanaged(i), field3.PointerSparseUnmanaged(i), field4.PointerSparseUnmanaged(i), field5.PointerSparseUnmanaged(i), field6.PointerSparseUnmanaged(i), field7.PointerSparseUnmanaged(i), field8.PointerSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseSharedUnmanaged(i), field1.PointerSparseSharedUnmanaged(i), field2.PointerSparseSharedUnmanaged(i), field3.PointerSparseSharedUnmanaged(i), field4.PointerSparseSharedUnmanaged(i), field5.PointerSparseSharedUnmanaged(i), field6.PointerSparseSharedUnmanaged(i), field7.PointerSparseSharedUnmanaged(i), field8.PointerSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerManaged(i), field1.PointerManaged(i), field2.PointerManaged(i), field3.PointerManaged(i), field4.PointerManaged(i), field5.PointerManaged(i), field6.PointerManaged(i), field7.PointerManaged(i), field8.PointerManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSharedManaged(i), field1.PointerSharedManaged(i), field2.PointerSharedManaged(i), field3.PointerSharedManaged(i), field4.PointerSharedManaged(i), field5.PointerSharedManaged(i), field6.PointerSharedManaged(i), field7.PointerSharedManaged(i), field8.PointerSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseManaged(i), field1.PointerSparseManaged(i), field2.PointerSparseManaged(i), field3.PointerSparseManaged(i), field4.PointerSparseManaged(i), field5.PointerSparseManaged(i), field6.PointerSparseManaged(i), field7.PointerSparseManaged(i), field8.PointerSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+                callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseSharedManaged(i), field1.PointerSparseSharedManaged(i), field2.PointerSparseSharedManaged(i), field3.PointerSparseSharedManaged(i), field4.PointerSparseSharedManaged(i), field5.PointerSparseSharedManaged(i), field6.PointerSparseSharedManaged(i), field7.PointerSparseSharedManaged(i), field8.PointerSparseSharedManaged(i));
+        }
     }
 
     /// <summary>
@@ -248,14 +1108,92 @@ public static void Each<T0, T1, T2, T3, T4, T5, T6, T7, T8>(Iter it, delegate*<I
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8);
+        IterationTechnique flags = it.GetIterationTechnique(9);
             
         Ecs.TableLock(it);
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8])
-            callback(it, i, (T0*)pointer0, (T1*)pointer1, (T2*)pointer2, (T3*)pointer3, (T4*)pointer4, (T5*)pointer5, (T6*)pointer6, (T7*)pointer7, (T8*)pointer8);
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>())
+        {
+            if (flags == IterationTechnique.None)
+                Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
+            else if (flags == IterationTechnique.Shared)
+                SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
+            else if (flags == IterationTechnique.Sparse)
+                SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
+            else if (flags == IterationTechnique.Shared)
+                SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
+            else if (flags == IterationTechnique.Sparse)
+                SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
+        }
             
         Ecs.TableUnlock(it);
+        
+        return;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Unmanaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerUnmanaged(i), field1.PointerUnmanaged(i), field2.PointerUnmanaged(i), field3.PointerUnmanaged(i), field4.PointerUnmanaged(i), field5.PointerUnmanaged(i), field6.PointerUnmanaged(i), field7.PointerUnmanaged(i), field8.PointerUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedUnmanaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSharedUnmanaged(i), field1.PointerSharedUnmanaged(i), field2.PointerSharedUnmanaged(i), field3.PointerSharedUnmanaged(i), field4.PointerSharedUnmanaged(i), field5.PointerSharedUnmanaged(i), field6.PointerSharedUnmanaged(i), field7.PointerSharedUnmanaged(i), field8.PointerSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseUnmanaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSparseUnmanaged(i), field1.PointerSparseUnmanaged(i), field2.PointerSparseUnmanaged(i), field3.PointerSparseUnmanaged(i), field4.PointerSparseUnmanaged(i), field5.PointerSparseUnmanaged(i), field6.PointerSparseUnmanaged(i), field7.PointerSparseUnmanaged(i), field8.PointerSparseUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedUnmanaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSparseSharedUnmanaged(i), field1.PointerSparseSharedUnmanaged(i), field2.PointerSparseSharedUnmanaged(i), field3.PointerSparseSharedUnmanaged(i), field4.PointerSparseSharedUnmanaged(i), field5.PointerSparseSharedUnmanaged(i), field6.PointerSparseSharedUnmanaged(i), field7.PointerSparseSharedUnmanaged(i), field8.PointerSparseSharedUnmanaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void Managed(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerManaged(i), field1.PointerManaged(i), field2.PointerManaged(i), field3.PointerManaged(i), field4.PointerManaged(i), field5.PointerManaged(i), field6.PointerManaged(i), field7.PointerManaged(i), field8.PointerManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SharedManaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSharedManaged(i), field1.PointerSharedManaged(i), field2.PointerSharedManaged(i), field3.PointerSharedManaged(i), field4.PointerSharedManaged(i), field5.PointerSharedManaged(i), field6.PointerSharedManaged(i), field7.PointerSharedManaged(i), field8.PointerSharedManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseManaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSparseManaged(i), field1.PointerSparseManaged(i), field2.PointerSparseManaged(i), field3.PointerSparseManaged(i), field4.PointerSparseManaged(i), field5.PointerSparseManaged(i), field6.PointerSparseManaged(i), field7.PointerSparseManaged(i), field8.PointerSparseManaged(i));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void SparseSharedManaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, void> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+                callback(it, i, field0.PointerSparseSharedManaged(i), field1.PointerSparseSharedManaged(i), field2.PointerSparseSharedManaged(i), field3.PointerSparseSharedManaged(i), field4.PointerSparseSharedManaged(i), field5.PointerSparseSharedManaged(i), field6.PointerSparseSharedManaged(i), field7.PointerSparseSharedManaged(i), field8.PointerSparseSharedManaged(i));
+        }
     }
 }
\ No newline at end of file
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/Invoker/Find/Iterator/T1.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/Invoker/Find/Iterator/T1.g.cs
index 4ba025c4..5fd1fed6 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/Invoker/Find/Iterator/T1.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/Invoker/Find/Iterator/T1.g.cs
@@ -1,5 +1,7 @@
 // Find/Iterator/T1.g.cs
 // File was auto-generated by /_/src/Flecs.NET.Codegen/Generators/Invoker.cs
+using System;
+using System.Runtime.CompilerServices;
 using Flecs.NET.Utilities;
 using static Flecs.NET.Bindings.flecs;
 
@@ -17,25 +19,135 @@ public static Entity Find<T0>(Iter it, Ecs.FindRefCallback<T0> callback)
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0);
-        int step0 = it.Step<T0>(0);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0);
+        IterationTechnique flags = it.GetIterationTechnique(1);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>())
         {
-            if (!callback(ref Managed.GetTypeRef<T0>(pointer0)))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, Ecs.FindRefCallback<T0> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, Ecs.FindRefCallback<T0> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, Ecs.FindRefCallback<T0> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, Ecs.FindRefCallback<T0> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, Ecs.FindRefCallback<T0> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, Ecs.FindRefCallback<T0> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, Ecs.FindRefCallback<T0> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, Ecs.FindRefCallback<T0> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 
     /// <summary>
@@ -48,25 +160,135 @@ public static Entity Find<T0>(Iter it, Ecs.FindEntityRefCallback<T0> callback)
     {
         int count = it.Handle->count; Ecs.Assert(it.Handle->count > 0, "No entities returned, use Iter() or Each() without the entity argument instead.");
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0);
-        int step0 = it.Step<T0>(0);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0);
+        IterationTechnique flags = it.GetIterationTechnique(1);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>())
         {
-            if (!callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref Managed.GetTypeRef<T0>(pointer0)))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, Ecs.FindEntityRefCallback<T0> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, Ecs.FindEntityRefCallback<T0> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, Ecs.FindEntityRefCallback<T0> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, Ecs.FindEntityRefCallback<T0> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, Ecs.FindEntityRefCallback<T0> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, Ecs.FindEntityRefCallback<T0> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, Ecs.FindEntityRefCallback<T0> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, Ecs.FindEntityRefCallback<T0> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 
     /// <summary>
@@ -79,25 +301,135 @@ public static Entity Find<T0>(Iter it, Ecs.FindIterRefCallback<T0> callback)
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0);
-        int step0 = it.Step<T0>(0);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0);
+        IterationTechnique flags = it.GetIterationTechnique(1);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>())
         {
-            if (!callback(it, i, ref Managed.GetTypeRef<T0>(pointer0)))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, Ecs.FindIterRefCallback<T0> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, Ecs.FindIterRefCallback<T0> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, Ecs.FindIterRefCallback<T0> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, Ecs.FindIterRefCallback<T0> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, Ecs.FindIterRefCallback<T0> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, Ecs.FindIterRefCallback<T0> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, Ecs.FindIterRefCallback<T0> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, Ecs.FindIterRefCallback<T0> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 
     /// <summary>
@@ -110,25 +442,135 @@ public static Entity Find<T0>(Iter it, delegate*<ref T0, bool> callback)
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0);
-        int step0 = it.Step<T0>(0);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0);
+        IterationTechnique flags = it.GetIterationTechnique(1);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>())
         {
-            if (!callback(ref Managed.GetTypeRef<T0>(pointer0)))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, delegate*<ref T0, bool> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, delegate*<ref T0, bool> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, delegate*<ref T0, bool> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, delegate*<ref T0, bool> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, delegate*<ref T0, bool> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, delegate*<ref T0, bool> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, delegate*<ref T0, bool> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, delegate*<ref T0, bool> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 
     /// <summary>
@@ -141,25 +583,135 @@ public static Entity Find<T0>(Iter it, delegate*<Entity, ref T0, bool> callback)
     {
         int count = it.Handle->count; Ecs.Assert(it.Handle->count > 0, "No entities returned, use Iter() or Each() without the entity argument instead.");
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0);
-        int step0 = it.Step<T0>(0);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0);
+        IterationTechnique flags = it.GetIterationTechnique(1);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>())
         {
-            if (!callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref Managed.GetTypeRef<T0>(pointer0)))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, delegate*<Entity, ref T0, bool> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, delegate*<Entity, ref T0, bool> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, delegate*<Entity, ref T0, bool> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, delegate*<Entity, ref T0, bool> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, delegate*<Entity, ref T0, bool> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, delegate*<Entity, ref T0, bool> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, delegate*<Entity, ref T0, bool> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, delegate*<Entity, ref T0, bool> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 
     /// <summary>
@@ -172,25 +724,135 @@ public static Entity Find<T0>(Iter it, delegate*<Iter, int, ref T0, bool> callba
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0);
-        int step0 = it.Step<T0>(0);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0);
+        IterationTechnique flags = it.GetIterationTechnique(1);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>())
         {
-            if (!callback(it, i, ref Managed.GetTypeRef<T0>(pointer0)))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, delegate*<Iter, int, ref T0, bool> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, delegate*<Iter, int, ref T0, bool> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, delegate*<Iter, int, ref T0, bool> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, delegate*<Iter, int, ref T0, bool> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, delegate*<Iter, int, ref T0, bool> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, delegate*<Iter, int, ref T0, bool> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, delegate*<Iter, int, ref T0, bool> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, delegate*<Iter, int, ref T0, bool> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 
     /// <summary>
@@ -203,25 +865,135 @@ public static Entity Find<T0>(Iter it, Ecs.FindPointerCallback<T0> callback)
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0);
-        int step0 = it.Step<T0>(0);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0);
+        IterationTechnique flags = it.GetIterationTechnique(1);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>())
         {
-            if (!callback((T0*)pointer0))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, Ecs.FindPointerCallback<T0> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, Ecs.FindPointerCallback<T0> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, Ecs.FindPointerCallback<T0> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, Ecs.FindPointerCallback<T0> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, Ecs.FindPointerCallback<T0> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, Ecs.FindPointerCallback<T0> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, Ecs.FindPointerCallback<T0> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, Ecs.FindPointerCallback<T0> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 
     /// <summary>
@@ -234,25 +1006,135 @@ public static Entity Find<T0>(Iter it, Ecs.FindEntityPointerCallback<T0> callbac
     {
         int count = it.Handle->count; Ecs.Assert(it.Handle->count > 0, "No entities returned, use Iter() or Each() without the entity argument instead.");
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0);
-        int step0 = it.Step<T0>(0);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0);
+        IterationTechnique flags = it.GetIterationTechnique(1);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>())
         {
-            if (!callback(new Entity(it.Handle->world, it.Handle->entities[i]), (T0*)pointer0))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, Ecs.FindEntityPointerCallback<T0> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, Ecs.FindEntityPointerCallback<T0> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, Ecs.FindEntityPointerCallback<T0> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, Ecs.FindEntityPointerCallback<T0> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, Ecs.FindEntityPointerCallback<T0> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, Ecs.FindEntityPointerCallback<T0> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, Ecs.FindEntityPointerCallback<T0> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, Ecs.FindEntityPointerCallback<T0> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 
     /// <summary>
@@ -265,25 +1147,135 @@ public static Entity Find<T0>(Iter it, Ecs.FindIterPointerCallback<T0> callback)
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0);
-        int step0 = it.Step<T0>(0);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0);
+        IterationTechnique flags = it.GetIterationTechnique(1);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>())
         {
-            if (!callback(it, i, (T0*)pointer0))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, Ecs.FindIterPointerCallback<T0> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, Ecs.FindIterPointerCallback<T0> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, Ecs.FindIterPointerCallback<T0> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, Ecs.FindIterPointerCallback<T0> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, Ecs.FindIterPointerCallback<T0> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, Ecs.FindIterPointerCallback<T0> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, Ecs.FindIterPointerCallback<T0> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, Ecs.FindIterPointerCallback<T0> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 
     /// <summary>
@@ -296,25 +1288,135 @@ public static Entity Find<T0>(Iter it, delegate*<T0*, bool> callback)
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0);
-        int step0 = it.Step<T0>(0);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0);
+        IterationTechnique flags = it.GetIterationTechnique(1);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>())
         {
-            if (!callback((T0*)pointer0))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, delegate*<T0*, bool> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, delegate*<T0*, bool> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, delegate*<T0*, bool> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, delegate*<T0*, bool> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, delegate*<T0*, bool> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, delegate*<T0*, bool> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, delegate*<T0*, bool> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, delegate*<T0*, bool> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 
     /// <summary>
@@ -327,25 +1429,135 @@ public static Entity Find<T0>(Iter it, delegate*<Entity, T0*, bool> callback)
     {
         int count = it.Handle->count; Ecs.Assert(it.Handle->count > 0, "No entities returned, use Iter() or Each() without the entity argument instead.");
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0);
-        int step0 = it.Step<T0>(0);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0);
+        IterationTechnique flags = it.GetIterationTechnique(1);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>())
         {
-            if (!callback(new Entity(it.Handle->world, it.Handle->entities[i]), (T0*)pointer0))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, delegate*<Entity, T0*, bool> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, delegate*<Entity, T0*, bool> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, delegate*<Entity, T0*, bool> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, delegate*<Entity, T0*, bool> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, delegate*<Entity, T0*, bool> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, delegate*<Entity, T0*, bool> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, delegate*<Entity, T0*, bool> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, delegate*<Entity, T0*, bool> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 
     /// <summary>
@@ -358,24 +1570,134 @@ public static Entity Find<T0>(Iter it, delegate*<Iter, int, T0*, bool> callback)
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0);
-        int step0 = it.Step<T0>(0);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0);
+        IterationTechnique flags = it.GetIterationTechnique(1);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>())
         {
-            if (!callback(it, i, (T0*)pointer0))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, delegate*<Iter, int, T0*, bool> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, delegate*<Iter, int, T0*, bool> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, delegate*<Iter, int, T0*, bool> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, delegate*<Iter, int, T0*, bool> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, delegate*<Iter, int, T0*, bool> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, delegate*<Iter, int, T0*, bool> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, delegate*<Iter, int, T0*, bool> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, delegate*<Iter, int, T0*, bool> callback, ref FieldData<T0> field0)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 }
\ No newline at end of file
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/Invoker/Find/Iterator/T10.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/Invoker/Find/Iterator/T10.g.cs
index 275adb7d..b6055bfa 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/Invoker/Find/Iterator/T10.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/Invoker/Find/Iterator/T10.g.cs
@@ -1,5 +1,7 @@
 // Find/Iterator/T10.g.cs
 // File was auto-generated by /_/src/Flecs.NET.Codegen/Generators/Invoker.cs
+using System;
+using System.Runtime.CompilerServices;
 using Flecs.NET.Utilities;
 using static Flecs.NET.Bindings.flecs;
 
@@ -17,25 +19,135 @@ public static Entity Find<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>(Iter it, Ecs.F
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8); byte* pointer9 = (byte*)it.GetPointer<T9>(9);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8); int step9 = it.Step<T9>(9);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8); FieldData<T9> field9 = it.GetFieldData<T9>(9);
+        IterationTechnique flags = it.GetIterationTechnique(10);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8], pointer9 = &pointer9[step9])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>() || RuntimeHelpers.IsReferenceOrContainsReferences<T9>())
         {
-            if (!callback(ref Managed.GetTypeRef<T0>(pointer0), ref Managed.GetTypeRef<T1>(pointer1), ref Managed.GetTypeRef<T2>(pointer2), ref Managed.GetTypeRef<T3>(pointer3), ref Managed.GetTypeRef<T4>(pointer4), ref Managed.GetTypeRef<T5>(pointer5), ref Managed.GetTypeRef<T6>(pointer6), ref Managed.GetTypeRef<T7>(pointer7), ref Managed.GetTypeRef<T8>(pointer8), ref Managed.GetTypeRef<T9>(pointer9)))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, Ecs.FindRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefUnmanaged(i), ref field1.RefUnmanaged(i), ref field2.RefUnmanaged(i), ref field3.RefUnmanaged(i), ref field4.RefUnmanaged(i), ref field5.RefUnmanaged(i), ref field6.RefUnmanaged(i), ref field7.RefUnmanaged(i), ref field8.RefUnmanaged(i), ref field9.RefUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, Ecs.FindRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSharedUnmanaged(i), ref field1.RefSharedUnmanaged(i), ref field2.RefSharedUnmanaged(i), ref field3.RefSharedUnmanaged(i), ref field4.RefSharedUnmanaged(i), ref field5.RefSharedUnmanaged(i), ref field6.RefSharedUnmanaged(i), ref field7.RefSharedUnmanaged(i), ref field8.RefSharedUnmanaged(i), ref field9.RefSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, Ecs.FindRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSparseUnmanaged(i), ref field1.RefSparseUnmanaged(i), ref field2.RefSparseUnmanaged(i), ref field3.RefSparseUnmanaged(i), ref field4.RefSparseUnmanaged(i), ref field5.RefSparseUnmanaged(i), ref field6.RefSparseUnmanaged(i), ref field7.RefSparseUnmanaged(i), ref field8.RefSparseUnmanaged(i), ref field9.RefSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, Ecs.FindRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSparseSharedUnmanaged(i), ref field1.RefSparseSharedUnmanaged(i), ref field2.RefSparseSharedUnmanaged(i), ref field3.RefSparseSharedUnmanaged(i), ref field4.RefSparseSharedUnmanaged(i), ref field5.RefSparseSharedUnmanaged(i), ref field6.RefSparseSharedUnmanaged(i), ref field7.RefSparseSharedUnmanaged(i), ref field8.RefSparseSharedUnmanaged(i), ref field9.RefSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, Ecs.FindRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefManaged(i), ref field1.RefManaged(i), ref field2.RefManaged(i), ref field3.RefManaged(i), ref field4.RefManaged(i), ref field5.RefManaged(i), ref field6.RefManaged(i), ref field7.RefManaged(i), ref field8.RefManaged(i), ref field9.RefManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, Ecs.FindRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSharedManaged(i), ref field1.RefSharedManaged(i), ref field2.RefSharedManaged(i), ref field3.RefSharedManaged(i), ref field4.RefSharedManaged(i), ref field5.RefSharedManaged(i), ref field6.RefSharedManaged(i), ref field7.RefSharedManaged(i), ref field8.RefSharedManaged(i), ref field9.RefSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, Ecs.FindRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSparseManaged(i), ref field1.RefSparseManaged(i), ref field2.RefSparseManaged(i), ref field3.RefSparseManaged(i), ref field4.RefSparseManaged(i), ref field5.RefSparseManaged(i), ref field6.RefSparseManaged(i), ref field7.RefSparseManaged(i), ref field8.RefSparseManaged(i), ref field9.RefSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, Ecs.FindRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSparseSharedManaged(i), ref field1.RefSparseSharedManaged(i), ref field2.RefSparseSharedManaged(i), ref field3.RefSparseSharedManaged(i), ref field4.RefSparseSharedManaged(i), ref field5.RefSparseSharedManaged(i), ref field6.RefSparseSharedManaged(i), ref field7.RefSparseSharedManaged(i), ref field8.RefSparseSharedManaged(i), ref field9.RefSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 
     /// <summary>
@@ -48,25 +160,135 @@ public static Entity Find<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>(Iter it, Ecs.F
     {
         int count = it.Handle->count; Ecs.Assert(it.Handle->count > 0, "No entities returned, use Iter() or Each() without the entity argument instead.");
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8); byte* pointer9 = (byte*)it.GetPointer<T9>(9);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8); int step9 = it.Step<T9>(9);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8); FieldData<T9> field9 = it.GetFieldData<T9>(9);
+        IterationTechnique flags = it.GetIterationTechnique(10);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8], pointer9 = &pointer9[step9])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>() || RuntimeHelpers.IsReferenceOrContainsReferences<T9>())
         {
-            if (!callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref Managed.GetTypeRef<T0>(pointer0), ref Managed.GetTypeRef<T1>(pointer1), ref Managed.GetTypeRef<T2>(pointer2), ref Managed.GetTypeRef<T3>(pointer3), ref Managed.GetTypeRef<T4>(pointer4), ref Managed.GetTypeRef<T5>(pointer5), ref Managed.GetTypeRef<T6>(pointer6), ref Managed.GetTypeRef<T7>(pointer7), ref Managed.GetTypeRef<T8>(pointer8), ref Managed.GetTypeRef<T9>(pointer9)))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefUnmanaged(i), ref field1.RefUnmanaged(i), ref field2.RefUnmanaged(i), ref field3.RefUnmanaged(i), ref field4.RefUnmanaged(i), ref field5.RefUnmanaged(i), ref field6.RefUnmanaged(i), ref field7.RefUnmanaged(i), ref field8.RefUnmanaged(i), ref field9.RefUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSharedUnmanaged(i), ref field1.RefSharedUnmanaged(i), ref field2.RefSharedUnmanaged(i), ref field3.RefSharedUnmanaged(i), ref field4.RefSharedUnmanaged(i), ref field5.RefSharedUnmanaged(i), ref field6.RefSharedUnmanaged(i), ref field7.RefSharedUnmanaged(i), ref field8.RefSharedUnmanaged(i), ref field9.RefSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseUnmanaged(i), ref field1.RefSparseUnmanaged(i), ref field2.RefSparseUnmanaged(i), ref field3.RefSparseUnmanaged(i), ref field4.RefSparseUnmanaged(i), ref field5.RefSparseUnmanaged(i), ref field6.RefSparseUnmanaged(i), ref field7.RefSparseUnmanaged(i), ref field8.RefSparseUnmanaged(i), ref field9.RefSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseSharedUnmanaged(i), ref field1.RefSparseSharedUnmanaged(i), ref field2.RefSparseSharedUnmanaged(i), ref field3.RefSparseSharedUnmanaged(i), ref field4.RefSparseSharedUnmanaged(i), ref field5.RefSparseSharedUnmanaged(i), ref field6.RefSparseSharedUnmanaged(i), ref field7.RefSparseSharedUnmanaged(i), ref field8.RefSparseSharedUnmanaged(i), ref field9.RefSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefManaged(i), ref field1.RefManaged(i), ref field2.RefManaged(i), ref field3.RefManaged(i), ref field4.RefManaged(i), ref field5.RefManaged(i), ref field6.RefManaged(i), ref field7.RefManaged(i), ref field8.RefManaged(i), ref field9.RefManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSharedManaged(i), ref field1.RefSharedManaged(i), ref field2.RefSharedManaged(i), ref field3.RefSharedManaged(i), ref field4.RefSharedManaged(i), ref field5.RefSharedManaged(i), ref field6.RefSharedManaged(i), ref field7.RefSharedManaged(i), ref field8.RefSharedManaged(i), ref field9.RefSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseManaged(i), ref field1.RefSparseManaged(i), ref field2.RefSparseManaged(i), ref field3.RefSparseManaged(i), ref field4.RefSparseManaged(i), ref field5.RefSparseManaged(i), ref field6.RefSparseManaged(i), ref field7.RefSparseManaged(i), ref field8.RefSparseManaged(i), ref field9.RefSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseSharedManaged(i), ref field1.RefSparseSharedManaged(i), ref field2.RefSparseSharedManaged(i), ref field3.RefSparseSharedManaged(i), ref field4.RefSparseSharedManaged(i), ref field5.RefSparseSharedManaged(i), ref field6.RefSparseSharedManaged(i), ref field7.RefSparseSharedManaged(i), ref field8.RefSparseSharedManaged(i), ref field9.RefSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 
     /// <summary>
@@ -79,25 +301,135 @@ public static Entity Find<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>(Iter it, Ecs.F
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8); byte* pointer9 = (byte*)it.GetPointer<T9>(9);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8); int step9 = it.Step<T9>(9);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8); FieldData<T9> field9 = it.GetFieldData<T9>(9);
+        IterationTechnique flags = it.GetIterationTechnique(10);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8], pointer9 = &pointer9[step9])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>() || RuntimeHelpers.IsReferenceOrContainsReferences<T9>())
         {
-            if (!callback(it, i, ref Managed.GetTypeRef<T0>(pointer0), ref Managed.GetTypeRef<T1>(pointer1), ref Managed.GetTypeRef<T2>(pointer2), ref Managed.GetTypeRef<T3>(pointer3), ref Managed.GetTypeRef<T4>(pointer4), ref Managed.GetTypeRef<T5>(pointer5), ref Managed.GetTypeRef<T6>(pointer6), ref Managed.GetTypeRef<T7>(pointer7), ref Managed.GetTypeRef<T8>(pointer8), ref Managed.GetTypeRef<T9>(pointer9)))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, Ecs.FindIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefUnmanaged(i), ref field1.RefUnmanaged(i), ref field2.RefUnmanaged(i), ref field3.RefUnmanaged(i), ref field4.RefUnmanaged(i), ref field5.RefUnmanaged(i), ref field6.RefUnmanaged(i), ref field7.RefUnmanaged(i), ref field8.RefUnmanaged(i), ref field9.RefUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, Ecs.FindIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSharedUnmanaged(i), ref field1.RefSharedUnmanaged(i), ref field2.RefSharedUnmanaged(i), ref field3.RefSharedUnmanaged(i), ref field4.RefSharedUnmanaged(i), ref field5.RefSharedUnmanaged(i), ref field6.RefSharedUnmanaged(i), ref field7.RefSharedUnmanaged(i), ref field8.RefSharedUnmanaged(i), ref field9.RefSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, Ecs.FindIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSparseUnmanaged(i), ref field1.RefSparseUnmanaged(i), ref field2.RefSparseUnmanaged(i), ref field3.RefSparseUnmanaged(i), ref field4.RefSparseUnmanaged(i), ref field5.RefSparseUnmanaged(i), ref field6.RefSparseUnmanaged(i), ref field7.RefSparseUnmanaged(i), ref field8.RefSparseUnmanaged(i), ref field9.RefSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, Ecs.FindIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSparseSharedUnmanaged(i), ref field1.RefSparseSharedUnmanaged(i), ref field2.RefSparseSharedUnmanaged(i), ref field3.RefSparseSharedUnmanaged(i), ref field4.RefSparseSharedUnmanaged(i), ref field5.RefSparseSharedUnmanaged(i), ref field6.RefSparseSharedUnmanaged(i), ref field7.RefSparseSharedUnmanaged(i), ref field8.RefSparseSharedUnmanaged(i), ref field9.RefSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, Ecs.FindIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefManaged(i), ref field1.RefManaged(i), ref field2.RefManaged(i), ref field3.RefManaged(i), ref field4.RefManaged(i), ref field5.RefManaged(i), ref field6.RefManaged(i), ref field7.RefManaged(i), ref field8.RefManaged(i), ref field9.RefManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, Ecs.FindIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSharedManaged(i), ref field1.RefSharedManaged(i), ref field2.RefSharedManaged(i), ref field3.RefSharedManaged(i), ref field4.RefSharedManaged(i), ref field5.RefSharedManaged(i), ref field6.RefSharedManaged(i), ref field7.RefSharedManaged(i), ref field8.RefSharedManaged(i), ref field9.RefSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, Ecs.FindIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSparseManaged(i), ref field1.RefSparseManaged(i), ref field2.RefSparseManaged(i), ref field3.RefSparseManaged(i), ref field4.RefSparseManaged(i), ref field5.RefSparseManaged(i), ref field6.RefSparseManaged(i), ref field7.RefSparseManaged(i), ref field8.RefSparseManaged(i), ref field9.RefSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, Ecs.FindIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSparseSharedManaged(i), ref field1.RefSparseSharedManaged(i), ref field2.RefSparseSharedManaged(i), ref field3.RefSparseSharedManaged(i), ref field4.RefSparseSharedManaged(i), ref field5.RefSparseSharedManaged(i), ref field6.RefSparseSharedManaged(i), ref field7.RefSparseSharedManaged(i), ref field8.RefSparseSharedManaged(i), ref field9.RefSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 
     /// <summary>
@@ -110,25 +442,135 @@ public static Entity Find<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>(Iter it, deleg
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8); byte* pointer9 = (byte*)it.GetPointer<T9>(9);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8); int step9 = it.Step<T9>(9);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8); FieldData<T9> field9 = it.GetFieldData<T9>(9);
+        IterationTechnique flags = it.GetIterationTechnique(10);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8], pointer9 = &pointer9[step9])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>() || RuntimeHelpers.IsReferenceOrContainsReferences<T9>())
         {
-            if (!callback(ref Managed.GetTypeRef<T0>(pointer0), ref Managed.GetTypeRef<T1>(pointer1), ref Managed.GetTypeRef<T2>(pointer2), ref Managed.GetTypeRef<T3>(pointer3), ref Managed.GetTypeRef<T4>(pointer4), ref Managed.GetTypeRef<T5>(pointer5), ref Managed.GetTypeRef<T6>(pointer6), ref Managed.GetTypeRef<T7>(pointer7), ref Managed.GetTypeRef<T8>(pointer8), ref Managed.GetTypeRef<T9>(pointer9)))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefUnmanaged(i), ref field1.RefUnmanaged(i), ref field2.RefUnmanaged(i), ref field3.RefUnmanaged(i), ref field4.RefUnmanaged(i), ref field5.RefUnmanaged(i), ref field6.RefUnmanaged(i), ref field7.RefUnmanaged(i), ref field8.RefUnmanaged(i), ref field9.RefUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSharedUnmanaged(i), ref field1.RefSharedUnmanaged(i), ref field2.RefSharedUnmanaged(i), ref field3.RefSharedUnmanaged(i), ref field4.RefSharedUnmanaged(i), ref field5.RefSharedUnmanaged(i), ref field6.RefSharedUnmanaged(i), ref field7.RefSharedUnmanaged(i), ref field8.RefSharedUnmanaged(i), ref field9.RefSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSparseUnmanaged(i), ref field1.RefSparseUnmanaged(i), ref field2.RefSparseUnmanaged(i), ref field3.RefSparseUnmanaged(i), ref field4.RefSparseUnmanaged(i), ref field5.RefSparseUnmanaged(i), ref field6.RefSparseUnmanaged(i), ref field7.RefSparseUnmanaged(i), ref field8.RefSparseUnmanaged(i), ref field9.RefSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSparseSharedUnmanaged(i), ref field1.RefSparseSharedUnmanaged(i), ref field2.RefSparseSharedUnmanaged(i), ref field3.RefSparseSharedUnmanaged(i), ref field4.RefSparseSharedUnmanaged(i), ref field5.RefSparseSharedUnmanaged(i), ref field6.RefSparseSharedUnmanaged(i), ref field7.RefSparseSharedUnmanaged(i), ref field8.RefSparseSharedUnmanaged(i), ref field9.RefSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefManaged(i), ref field1.RefManaged(i), ref field2.RefManaged(i), ref field3.RefManaged(i), ref field4.RefManaged(i), ref field5.RefManaged(i), ref field6.RefManaged(i), ref field7.RefManaged(i), ref field8.RefManaged(i), ref field9.RefManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSharedManaged(i), ref field1.RefSharedManaged(i), ref field2.RefSharedManaged(i), ref field3.RefSharedManaged(i), ref field4.RefSharedManaged(i), ref field5.RefSharedManaged(i), ref field6.RefSharedManaged(i), ref field7.RefSharedManaged(i), ref field8.RefSharedManaged(i), ref field9.RefSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSparseManaged(i), ref field1.RefSparseManaged(i), ref field2.RefSparseManaged(i), ref field3.RefSparseManaged(i), ref field4.RefSparseManaged(i), ref field5.RefSparseManaged(i), ref field6.RefSparseManaged(i), ref field7.RefSparseManaged(i), ref field8.RefSparseManaged(i), ref field9.RefSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSparseSharedManaged(i), ref field1.RefSparseSharedManaged(i), ref field2.RefSparseSharedManaged(i), ref field3.RefSparseSharedManaged(i), ref field4.RefSparseSharedManaged(i), ref field5.RefSparseSharedManaged(i), ref field6.RefSparseSharedManaged(i), ref field7.RefSparseSharedManaged(i), ref field8.RefSparseSharedManaged(i), ref field9.RefSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 
     /// <summary>
@@ -141,25 +583,135 @@ public static Entity Find<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>(Iter it, deleg
     {
         int count = it.Handle->count; Ecs.Assert(it.Handle->count > 0, "No entities returned, use Iter() or Each() without the entity argument instead.");
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8); byte* pointer9 = (byte*)it.GetPointer<T9>(9);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8); int step9 = it.Step<T9>(9);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8); FieldData<T9> field9 = it.GetFieldData<T9>(9);
+        IterationTechnique flags = it.GetIterationTechnique(10);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8], pointer9 = &pointer9[step9])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>() || RuntimeHelpers.IsReferenceOrContainsReferences<T9>())
         {
-            if (!callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref Managed.GetTypeRef<T0>(pointer0), ref Managed.GetTypeRef<T1>(pointer1), ref Managed.GetTypeRef<T2>(pointer2), ref Managed.GetTypeRef<T3>(pointer3), ref Managed.GetTypeRef<T4>(pointer4), ref Managed.GetTypeRef<T5>(pointer5), ref Managed.GetTypeRef<T6>(pointer6), ref Managed.GetTypeRef<T7>(pointer7), ref Managed.GetTypeRef<T8>(pointer8), ref Managed.GetTypeRef<T9>(pointer9)))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefUnmanaged(i), ref field1.RefUnmanaged(i), ref field2.RefUnmanaged(i), ref field3.RefUnmanaged(i), ref field4.RefUnmanaged(i), ref field5.RefUnmanaged(i), ref field6.RefUnmanaged(i), ref field7.RefUnmanaged(i), ref field8.RefUnmanaged(i), ref field9.RefUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSharedUnmanaged(i), ref field1.RefSharedUnmanaged(i), ref field2.RefSharedUnmanaged(i), ref field3.RefSharedUnmanaged(i), ref field4.RefSharedUnmanaged(i), ref field5.RefSharedUnmanaged(i), ref field6.RefSharedUnmanaged(i), ref field7.RefSharedUnmanaged(i), ref field8.RefSharedUnmanaged(i), ref field9.RefSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseUnmanaged(i), ref field1.RefSparseUnmanaged(i), ref field2.RefSparseUnmanaged(i), ref field3.RefSparseUnmanaged(i), ref field4.RefSparseUnmanaged(i), ref field5.RefSparseUnmanaged(i), ref field6.RefSparseUnmanaged(i), ref field7.RefSparseUnmanaged(i), ref field8.RefSparseUnmanaged(i), ref field9.RefSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseSharedUnmanaged(i), ref field1.RefSparseSharedUnmanaged(i), ref field2.RefSparseSharedUnmanaged(i), ref field3.RefSparseSharedUnmanaged(i), ref field4.RefSparseSharedUnmanaged(i), ref field5.RefSparseSharedUnmanaged(i), ref field6.RefSparseSharedUnmanaged(i), ref field7.RefSparseSharedUnmanaged(i), ref field8.RefSparseSharedUnmanaged(i), ref field9.RefSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefManaged(i), ref field1.RefManaged(i), ref field2.RefManaged(i), ref field3.RefManaged(i), ref field4.RefManaged(i), ref field5.RefManaged(i), ref field6.RefManaged(i), ref field7.RefManaged(i), ref field8.RefManaged(i), ref field9.RefManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSharedManaged(i), ref field1.RefSharedManaged(i), ref field2.RefSharedManaged(i), ref field3.RefSharedManaged(i), ref field4.RefSharedManaged(i), ref field5.RefSharedManaged(i), ref field6.RefSharedManaged(i), ref field7.RefSharedManaged(i), ref field8.RefSharedManaged(i), ref field9.RefSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseManaged(i), ref field1.RefSparseManaged(i), ref field2.RefSparseManaged(i), ref field3.RefSparseManaged(i), ref field4.RefSparseManaged(i), ref field5.RefSparseManaged(i), ref field6.RefSparseManaged(i), ref field7.RefSparseManaged(i), ref field8.RefSparseManaged(i), ref field9.RefSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseSharedManaged(i), ref field1.RefSparseSharedManaged(i), ref field2.RefSparseSharedManaged(i), ref field3.RefSparseSharedManaged(i), ref field4.RefSparseSharedManaged(i), ref field5.RefSparseSharedManaged(i), ref field6.RefSparseSharedManaged(i), ref field7.RefSparseSharedManaged(i), ref field8.RefSparseSharedManaged(i), ref field9.RefSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 
     /// <summary>
@@ -172,25 +724,135 @@ public static Entity Find<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>(Iter it, deleg
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8); byte* pointer9 = (byte*)it.GetPointer<T9>(9);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8); int step9 = it.Step<T9>(9);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8); FieldData<T9> field9 = it.GetFieldData<T9>(9);
+        IterationTechnique flags = it.GetIterationTechnique(10);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8], pointer9 = &pointer9[step9])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>() || RuntimeHelpers.IsReferenceOrContainsReferences<T9>())
         {
-            if (!callback(it, i, ref Managed.GetTypeRef<T0>(pointer0), ref Managed.GetTypeRef<T1>(pointer1), ref Managed.GetTypeRef<T2>(pointer2), ref Managed.GetTypeRef<T3>(pointer3), ref Managed.GetTypeRef<T4>(pointer4), ref Managed.GetTypeRef<T5>(pointer5), ref Managed.GetTypeRef<T6>(pointer6), ref Managed.GetTypeRef<T7>(pointer7), ref Managed.GetTypeRef<T8>(pointer8), ref Managed.GetTypeRef<T9>(pointer9)))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefUnmanaged(i), ref field1.RefUnmanaged(i), ref field2.RefUnmanaged(i), ref field3.RefUnmanaged(i), ref field4.RefUnmanaged(i), ref field5.RefUnmanaged(i), ref field6.RefUnmanaged(i), ref field7.RefUnmanaged(i), ref field8.RefUnmanaged(i), ref field9.RefUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSharedUnmanaged(i), ref field1.RefSharedUnmanaged(i), ref field2.RefSharedUnmanaged(i), ref field3.RefSharedUnmanaged(i), ref field4.RefSharedUnmanaged(i), ref field5.RefSharedUnmanaged(i), ref field6.RefSharedUnmanaged(i), ref field7.RefSharedUnmanaged(i), ref field8.RefSharedUnmanaged(i), ref field9.RefSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSparseUnmanaged(i), ref field1.RefSparseUnmanaged(i), ref field2.RefSparseUnmanaged(i), ref field3.RefSparseUnmanaged(i), ref field4.RefSparseUnmanaged(i), ref field5.RefSparseUnmanaged(i), ref field6.RefSparseUnmanaged(i), ref field7.RefSparseUnmanaged(i), ref field8.RefSparseUnmanaged(i), ref field9.RefSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSparseSharedUnmanaged(i), ref field1.RefSparseSharedUnmanaged(i), ref field2.RefSparseSharedUnmanaged(i), ref field3.RefSparseSharedUnmanaged(i), ref field4.RefSparseSharedUnmanaged(i), ref field5.RefSparseSharedUnmanaged(i), ref field6.RefSparseSharedUnmanaged(i), ref field7.RefSparseSharedUnmanaged(i), ref field8.RefSparseSharedUnmanaged(i), ref field9.RefSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefManaged(i), ref field1.RefManaged(i), ref field2.RefManaged(i), ref field3.RefManaged(i), ref field4.RefManaged(i), ref field5.RefManaged(i), ref field6.RefManaged(i), ref field7.RefManaged(i), ref field8.RefManaged(i), ref field9.RefManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSharedManaged(i), ref field1.RefSharedManaged(i), ref field2.RefSharedManaged(i), ref field3.RefSharedManaged(i), ref field4.RefSharedManaged(i), ref field5.RefSharedManaged(i), ref field6.RefSharedManaged(i), ref field7.RefSharedManaged(i), ref field8.RefSharedManaged(i), ref field9.RefSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSparseManaged(i), ref field1.RefSparseManaged(i), ref field2.RefSparseManaged(i), ref field3.RefSparseManaged(i), ref field4.RefSparseManaged(i), ref field5.RefSparseManaged(i), ref field6.RefSparseManaged(i), ref field7.RefSparseManaged(i), ref field8.RefSparseManaged(i), ref field9.RefSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSparseSharedManaged(i), ref field1.RefSparseSharedManaged(i), ref field2.RefSparseSharedManaged(i), ref field3.RefSparseSharedManaged(i), ref field4.RefSparseSharedManaged(i), ref field5.RefSparseSharedManaged(i), ref field6.RefSparseSharedManaged(i), ref field7.RefSparseSharedManaged(i), ref field8.RefSparseSharedManaged(i), ref field9.RefSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 
     /// <summary>
@@ -203,25 +865,135 @@ public static Entity Find<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>(Iter it, Ecs.F
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8); byte* pointer9 = (byte*)it.GetPointer<T9>(9);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8); int step9 = it.Step<T9>(9);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8); FieldData<T9> field9 = it.GetFieldData<T9>(9);
+        IterationTechnique flags = it.GetIterationTechnique(10);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8], pointer9 = &pointer9[step9])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>() || RuntimeHelpers.IsReferenceOrContainsReferences<T9>())
         {
-            if (!callback((T0*)pointer0, (T1*)pointer1, (T2*)pointer2, (T3*)pointer3, (T4*)pointer4, (T5*)pointer5, (T6*)pointer6, (T7*)pointer7, (T8*)pointer8, (T9*)pointer9))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, Ecs.FindPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerUnmanaged(i), field1.PointerUnmanaged(i), field2.PointerUnmanaged(i), field3.PointerUnmanaged(i), field4.PointerUnmanaged(i), field5.PointerUnmanaged(i), field6.PointerUnmanaged(i), field7.PointerUnmanaged(i), field8.PointerUnmanaged(i), field9.PointerUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, Ecs.FindPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSharedUnmanaged(i), field1.PointerSharedUnmanaged(i), field2.PointerSharedUnmanaged(i), field3.PointerSharedUnmanaged(i), field4.PointerSharedUnmanaged(i), field5.PointerSharedUnmanaged(i), field6.PointerSharedUnmanaged(i), field7.PointerSharedUnmanaged(i), field8.PointerSharedUnmanaged(i), field9.PointerSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, Ecs.FindPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSparseUnmanaged(i), field1.PointerSparseUnmanaged(i), field2.PointerSparseUnmanaged(i), field3.PointerSparseUnmanaged(i), field4.PointerSparseUnmanaged(i), field5.PointerSparseUnmanaged(i), field6.PointerSparseUnmanaged(i), field7.PointerSparseUnmanaged(i), field8.PointerSparseUnmanaged(i), field9.PointerSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, Ecs.FindPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSparseSharedUnmanaged(i), field1.PointerSparseSharedUnmanaged(i), field2.PointerSparseSharedUnmanaged(i), field3.PointerSparseSharedUnmanaged(i), field4.PointerSparseSharedUnmanaged(i), field5.PointerSparseSharedUnmanaged(i), field6.PointerSparseSharedUnmanaged(i), field7.PointerSparseSharedUnmanaged(i), field8.PointerSparseSharedUnmanaged(i), field9.PointerSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, Ecs.FindPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerManaged(i), field1.PointerManaged(i), field2.PointerManaged(i), field3.PointerManaged(i), field4.PointerManaged(i), field5.PointerManaged(i), field6.PointerManaged(i), field7.PointerManaged(i), field8.PointerManaged(i), field9.PointerManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, Ecs.FindPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSharedManaged(i), field1.PointerSharedManaged(i), field2.PointerSharedManaged(i), field3.PointerSharedManaged(i), field4.PointerSharedManaged(i), field5.PointerSharedManaged(i), field6.PointerSharedManaged(i), field7.PointerSharedManaged(i), field8.PointerSharedManaged(i), field9.PointerSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, Ecs.FindPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSparseManaged(i), field1.PointerSparseManaged(i), field2.PointerSparseManaged(i), field3.PointerSparseManaged(i), field4.PointerSparseManaged(i), field5.PointerSparseManaged(i), field6.PointerSparseManaged(i), field7.PointerSparseManaged(i), field8.PointerSparseManaged(i), field9.PointerSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, Ecs.FindPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSparseSharedManaged(i), field1.PointerSparseSharedManaged(i), field2.PointerSparseSharedManaged(i), field3.PointerSparseSharedManaged(i), field4.PointerSparseSharedManaged(i), field5.PointerSparseSharedManaged(i), field6.PointerSparseSharedManaged(i), field7.PointerSparseSharedManaged(i), field8.PointerSparseSharedManaged(i), field9.PointerSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 
     /// <summary>
@@ -234,25 +1006,135 @@ public static Entity Find<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>(Iter it, Ecs.F
     {
         int count = it.Handle->count; Ecs.Assert(it.Handle->count > 0, "No entities returned, use Iter() or Each() without the entity argument instead.");
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8); byte* pointer9 = (byte*)it.GetPointer<T9>(9);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8); int step9 = it.Step<T9>(9);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8); FieldData<T9> field9 = it.GetFieldData<T9>(9);
+        IterationTechnique flags = it.GetIterationTechnique(10);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8], pointer9 = &pointer9[step9])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>() || RuntimeHelpers.IsReferenceOrContainsReferences<T9>())
         {
-            if (!callback(new Entity(it.Handle->world, it.Handle->entities[i]), (T0*)pointer0, (T1*)pointer1, (T2*)pointer2, (T3*)pointer3, (T4*)pointer4, (T5*)pointer5, (T6*)pointer6, (T7*)pointer7, (T8*)pointer8, (T9*)pointer9))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerUnmanaged(i), field1.PointerUnmanaged(i), field2.PointerUnmanaged(i), field3.PointerUnmanaged(i), field4.PointerUnmanaged(i), field5.PointerUnmanaged(i), field6.PointerUnmanaged(i), field7.PointerUnmanaged(i), field8.PointerUnmanaged(i), field9.PointerUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSharedUnmanaged(i), field1.PointerSharedUnmanaged(i), field2.PointerSharedUnmanaged(i), field3.PointerSharedUnmanaged(i), field4.PointerSharedUnmanaged(i), field5.PointerSharedUnmanaged(i), field6.PointerSharedUnmanaged(i), field7.PointerSharedUnmanaged(i), field8.PointerSharedUnmanaged(i), field9.PointerSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseUnmanaged(i), field1.PointerSparseUnmanaged(i), field2.PointerSparseUnmanaged(i), field3.PointerSparseUnmanaged(i), field4.PointerSparseUnmanaged(i), field5.PointerSparseUnmanaged(i), field6.PointerSparseUnmanaged(i), field7.PointerSparseUnmanaged(i), field8.PointerSparseUnmanaged(i), field9.PointerSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseSharedUnmanaged(i), field1.PointerSparseSharedUnmanaged(i), field2.PointerSparseSharedUnmanaged(i), field3.PointerSparseSharedUnmanaged(i), field4.PointerSparseSharedUnmanaged(i), field5.PointerSparseSharedUnmanaged(i), field6.PointerSparseSharedUnmanaged(i), field7.PointerSparseSharedUnmanaged(i), field8.PointerSparseSharedUnmanaged(i), field9.PointerSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerManaged(i), field1.PointerManaged(i), field2.PointerManaged(i), field3.PointerManaged(i), field4.PointerManaged(i), field5.PointerManaged(i), field6.PointerManaged(i), field7.PointerManaged(i), field8.PointerManaged(i), field9.PointerManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSharedManaged(i), field1.PointerSharedManaged(i), field2.PointerSharedManaged(i), field3.PointerSharedManaged(i), field4.PointerSharedManaged(i), field5.PointerSharedManaged(i), field6.PointerSharedManaged(i), field7.PointerSharedManaged(i), field8.PointerSharedManaged(i), field9.PointerSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseManaged(i), field1.PointerSparseManaged(i), field2.PointerSparseManaged(i), field3.PointerSparseManaged(i), field4.PointerSparseManaged(i), field5.PointerSparseManaged(i), field6.PointerSparseManaged(i), field7.PointerSparseManaged(i), field8.PointerSparseManaged(i), field9.PointerSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseSharedManaged(i), field1.PointerSparseSharedManaged(i), field2.PointerSparseSharedManaged(i), field3.PointerSparseSharedManaged(i), field4.PointerSparseSharedManaged(i), field5.PointerSparseSharedManaged(i), field6.PointerSparseSharedManaged(i), field7.PointerSparseSharedManaged(i), field8.PointerSparseSharedManaged(i), field9.PointerSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 
     /// <summary>
@@ -265,25 +1147,135 @@ public static Entity Find<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>(Iter it, Ecs.F
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8); byte* pointer9 = (byte*)it.GetPointer<T9>(9);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8); int step9 = it.Step<T9>(9);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8); FieldData<T9> field9 = it.GetFieldData<T9>(9);
+        IterationTechnique flags = it.GetIterationTechnique(10);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8], pointer9 = &pointer9[step9])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>() || RuntimeHelpers.IsReferenceOrContainsReferences<T9>())
         {
-            if (!callback(it, i, (T0*)pointer0, (T1*)pointer1, (T2*)pointer2, (T3*)pointer3, (T4*)pointer4, (T5*)pointer5, (T6*)pointer6, (T7*)pointer7, (T8*)pointer8, (T9*)pointer9))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerUnmanaged(i), field1.PointerUnmanaged(i), field2.PointerUnmanaged(i), field3.PointerUnmanaged(i), field4.PointerUnmanaged(i), field5.PointerUnmanaged(i), field6.PointerUnmanaged(i), field7.PointerUnmanaged(i), field8.PointerUnmanaged(i), field9.PointerUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSharedUnmanaged(i), field1.PointerSharedUnmanaged(i), field2.PointerSharedUnmanaged(i), field3.PointerSharedUnmanaged(i), field4.PointerSharedUnmanaged(i), field5.PointerSharedUnmanaged(i), field6.PointerSharedUnmanaged(i), field7.PointerSharedUnmanaged(i), field8.PointerSharedUnmanaged(i), field9.PointerSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSparseUnmanaged(i), field1.PointerSparseUnmanaged(i), field2.PointerSparseUnmanaged(i), field3.PointerSparseUnmanaged(i), field4.PointerSparseUnmanaged(i), field5.PointerSparseUnmanaged(i), field6.PointerSparseUnmanaged(i), field7.PointerSparseUnmanaged(i), field8.PointerSparseUnmanaged(i), field9.PointerSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSparseSharedUnmanaged(i), field1.PointerSparseSharedUnmanaged(i), field2.PointerSparseSharedUnmanaged(i), field3.PointerSparseSharedUnmanaged(i), field4.PointerSparseSharedUnmanaged(i), field5.PointerSparseSharedUnmanaged(i), field6.PointerSparseSharedUnmanaged(i), field7.PointerSparseSharedUnmanaged(i), field8.PointerSparseSharedUnmanaged(i), field9.PointerSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerManaged(i), field1.PointerManaged(i), field2.PointerManaged(i), field3.PointerManaged(i), field4.PointerManaged(i), field5.PointerManaged(i), field6.PointerManaged(i), field7.PointerManaged(i), field8.PointerManaged(i), field9.PointerManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSharedManaged(i), field1.PointerSharedManaged(i), field2.PointerSharedManaged(i), field3.PointerSharedManaged(i), field4.PointerSharedManaged(i), field5.PointerSharedManaged(i), field6.PointerSharedManaged(i), field7.PointerSharedManaged(i), field8.PointerSharedManaged(i), field9.PointerSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSparseManaged(i), field1.PointerSparseManaged(i), field2.PointerSparseManaged(i), field3.PointerSparseManaged(i), field4.PointerSparseManaged(i), field5.PointerSparseManaged(i), field6.PointerSparseManaged(i), field7.PointerSparseManaged(i), field8.PointerSparseManaged(i), field9.PointerSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSparseSharedManaged(i), field1.PointerSparseSharedManaged(i), field2.PointerSparseSharedManaged(i), field3.PointerSparseSharedManaged(i), field4.PointerSparseSharedManaged(i), field5.PointerSparseSharedManaged(i), field6.PointerSparseSharedManaged(i), field7.PointerSparseSharedManaged(i), field8.PointerSparseSharedManaged(i), field9.PointerSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 
     /// <summary>
@@ -296,25 +1288,135 @@ public static Entity Find<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>(Iter it, deleg
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8); byte* pointer9 = (byte*)it.GetPointer<T9>(9);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8); int step9 = it.Step<T9>(9);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8); FieldData<T9> field9 = it.GetFieldData<T9>(9);
+        IterationTechnique flags = it.GetIterationTechnique(10);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8], pointer9 = &pointer9[step9])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>() || RuntimeHelpers.IsReferenceOrContainsReferences<T9>())
         {
-            if (!callback((T0*)pointer0, (T1*)pointer1, (T2*)pointer2, (T3*)pointer3, (T4*)pointer4, (T5*)pointer5, (T6*)pointer6, (T7*)pointer7, (T8*)pointer8, (T9*)pointer9))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerUnmanaged(i), field1.PointerUnmanaged(i), field2.PointerUnmanaged(i), field3.PointerUnmanaged(i), field4.PointerUnmanaged(i), field5.PointerUnmanaged(i), field6.PointerUnmanaged(i), field7.PointerUnmanaged(i), field8.PointerUnmanaged(i), field9.PointerUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSharedUnmanaged(i), field1.PointerSharedUnmanaged(i), field2.PointerSharedUnmanaged(i), field3.PointerSharedUnmanaged(i), field4.PointerSharedUnmanaged(i), field5.PointerSharedUnmanaged(i), field6.PointerSharedUnmanaged(i), field7.PointerSharedUnmanaged(i), field8.PointerSharedUnmanaged(i), field9.PointerSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSparseUnmanaged(i), field1.PointerSparseUnmanaged(i), field2.PointerSparseUnmanaged(i), field3.PointerSparseUnmanaged(i), field4.PointerSparseUnmanaged(i), field5.PointerSparseUnmanaged(i), field6.PointerSparseUnmanaged(i), field7.PointerSparseUnmanaged(i), field8.PointerSparseUnmanaged(i), field9.PointerSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSparseSharedUnmanaged(i), field1.PointerSparseSharedUnmanaged(i), field2.PointerSparseSharedUnmanaged(i), field3.PointerSparseSharedUnmanaged(i), field4.PointerSparseSharedUnmanaged(i), field5.PointerSparseSharedUnmanaged(i), field6.PointerSparseSharedUnmanaged(i), field7.PointerSparseSharedUnmanaged(i), field8.PointerSparseSharedUnmanaged(i), field9.PointerSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerManaged(i), field1.PointerManaged(i), field2.PointerManaged(i), field3.PointerManaged(i), field4.PointerManaged(i), field5.PointerManaged(i), field6.PointerManaged(i), field7.PointerManaged(i), field8.PointerManaged(i), field9.PointerManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSharedManaged(i), field1.PointerSharedManaged(i), field2.PointerSharedManaged(i), field3.PointerSharedManaged(i), field4.PointerSharedManaged(i), field5.PointerSharedManaged(i), field6.PointerSharedManaged(i), field7.PointerSharedManaged(i), field8.PointerSharedManaged(i), field9.PointerSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSparseManaged(i), field1.PointerSparseManaged(i), field2.PointerSparseManaged(i), field3.PointerSparseManaged(i), field4.PointerSparseManaged(i), field5.PointerSparseManaged(i), field6.PointerSparseManaged(i), field7.PointerSparseManaged(i), field8.PointerSparseManaged(i), field9.PointerSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSparseSharedManaged(i), field1.PointerSparseSharedManaged(i), field2.PointerSparseSharedManaged(i), field3.PointerSparseSharedManaged(i), field4.PointerSparseSharedManaged(i), field5.PointerSparseSharedManaged(i), field6.PointerSparseSharedManaged(i), field7.PointerSparseSharedManaged(i), field8.PointerSparseSharedManaged(i), field9.PointerSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 
     /// <summary>
@@ -327,25 +1429,135 @@ public static Entity Find<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>(Iter it, deleg
     {
         int count = it.Handle->count; Ecs.Assert(it.Handle->count > 0, "No entities returned, use Iter() or Each() without the entity argument instead.");
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8); byte* pointer9 = (byte*)it.GetPointer<T9>(9);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8); int step9 = it.Step<T9>(9);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8); FieldData<T9> field9 = it.GetFieldData<T9>(9);
+        IterationTechnique flags = it.GetIterationTechnique(10);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8], pointer9 = &pointer9[step9])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>() || RuntimeHelpers.IsReferenceOrContainsReferences<T9>())
         {
-            if (!callback(new Entity(it.Handle->world, it.Handle->entities[i]), (T0*)pointer0, (T1*)pointer1, (T2*)pointer2, (T3*)pointer3, (T4*)pointer4, (T5*)pointer5, (T6*)pointer6, (T7*)pointer7, (T8*)pointer8, (T9*)pointer9))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerUnmanaged(i), field1.PointerUnmanaged(i), field2.PointerUnmanaged(i), field3.PointerUnmanaged(i), field4.PointerUnmanaged(i), field5.PointerUnmanaged(i), field6.PointerUnmanaged(i), field7.PointerUnmanaged(i), field8.PointerUnmanaged(i), field9.PointerUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSharedUnmanaged(i), field1.PointerSharedUnmanaged(i), field2.PointerSharedUnmanaged(i), field3.PointerSharedUnmanaged(i), field4.PointerSharedUnmanaged(i), field5.PointerSharedUnmanaged(i), field6.PointerSharedUnmanaged(i), field7.PointerSharedUnmanaged(i), field8.PointerSharedUnmanaged(i), field9.PointerSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseUnmanaged(i), field1.PointerSparseUnmanaged(i), field2.PointerSparseUnmanaged(i), field3.PointerSparseUnmanaged(i), field4.PointerSparseUnmanaged(i), field5.PointerSparseUnmanaged(i), field6.PointerSparseUnmanaged(i), field7.PointerSparseUnmanaged(i), field8.PointerSparseUnmanaged(i), field9.PointerSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseSharedUnmanaged(i), field1.PointerSparseSharedUnmanaged(i), field2.PointerSparseSharedUnmanaged(i), field3.PointerSparseSharedUnmanaged(i), field4.PointerSparseSharedUnmanaged(i), field5.PointerSparseSharedUnmanaged(i), field6.PointerSparseSharedUnmanaged(i), field7.PointerSparseSharedUnmanaged(i), field8.PointerSparseSharedUnmanaged(i), field9.PointerSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerManaged(i), field1.PointerManaged(i), field2.PointerManaged(i), field3.PointerManaged(i), field4.PointerManaged(i), field5.PointerManaged(i), field6.PointerManaged(i), field7.PointerManaged(i), field8.PointerManaged(i), field9.PointerManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSharedManaged(i), field1.PointerSharedManaged(i), field2.PointerSharedManaged(i), field3.PointerSharedManaged(i), field4.PointerSharedManaged(i), field5.PointerSharedManaged(i), field6.PointerSharedManaged(i), field7.PointerSharedManaged(i), field8.PointerSharedManaged(i), field9.PointerSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseManaged(i), field1.PointerSparseManaged(i), field2.PointerSparseManaged(i), field3.PointerSparseManaged(i), field4.PointerSparseManaged(i), field5.PointerSparseManaged(i), field6.PointerSparseManaged(i), field7.PointerSparseManaged(i), field8.PointerSparseManaged(i), field9.PointerSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseSharedManaged(i), field1.PointerSparseSharedManaged(i), field2.PointerSparseSharedManaged(i), field3.PointerSparseSharedManaged(i), field4.PointerSparseSharedManaged(i), field5.PointerSparseSharedManaged(i), field6.PointerSparseSharedManaged(i), field7.PointerSparseSharedManaged(i), field8.PointerSparseSharedManaged(i), field9.PointerSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 
     /// <summary>
@@ -358,24 +1570,134 @@ public static Entity Find<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>(Iter it, deleg
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8); byte* pointer9 = (byte*)it.GetPointer<T9>(9);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8); int step9 = it.Step<T9>(9);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8); FieldData<T9> field9 = it.GetFieldData<T9>(9);
+        IterationTechnique flags = it.GetIterationTechnique(10);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8], pointer9 = &pointer9[step9])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>() || RuntimeHelpers.IsReferenceOrContainsReferences<T9>())
         {
-            if (!callback(it, i, (T0*)pointer0, (T1*)pointer1, (T2*)pointer2, (T3*)pointer3, (T4*)pointer4, (T5*)pointer5, (T6*)pointer6, (T7*)pointer7, (T8*)pointer8, (T9*)pointer9))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerUnmanaged(i), field1.PointerUnmanaged(i), field2.PointerUnmanaged(i), field3.PointerUnmanaged(i), field4.PointerUnmanaged(i), field5.PointerUnmanaged(i), field6.PointerUnmanaged(i), field7.PointerUnmanaged(i), field8.PointerUnmanaged(i), field9.PointerUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSharedUnmanaged(i), field1.PointerSharedUnmanaged(i), field2.PointerSharedUnmanaged(i), field3.PointerSharedUnmanaged(i), field4.PointerSharedUnmanaged(i), field5.PointerSharedUnmanaged(i), field6.PointerSharedUnmanaged(i), field7.PointerSharedUnmanaged(i), field8.PointerSharedUnmanaged(i), field9.PointerSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSparseUnmanaged(i), field1.PointerSparseUnmanaged(i), field2.PointerSparseUnmanaged(i), field3.PointerSparseUnmanaged(i), field4.PointerSparseUnmanaged(i), field5.PointerSparseUnmanaged(i), field6.PointerSparseUnmanaged(i), field7.PointerSparseUnmanaged(i), field8.PointerSparseUnmanaged(i), field9.PointerSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSparseSharedUnmanaged(i), field1.PointerSparseSharedUnmanaged(i), field2.PointerSparseSharedUnmanaged(i), field3.PointerSparseSharedUnmanaged(i), field4.PointerSparseSharedUnmanaged(i), field5.PointerSparseSharedUnmanaged(i), field6.PointerSparseSharedUnmanaged(i), field7.PointerSparseSharedUnmanaged(i), field8.PointerSparseSharedUnmanaged(i), field9.PointerSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerManaged(i), field1.PointerManaged(i), field2.PointerManaged(i), field3.PointerManaged(i), field4.PointerManaged(i), field5.PointerManaged(i), field6.PointerManaged(i), field7.PointerManaged(i), field8.PointerManaged(i), field9.PointerManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSharedManaged(i), field1.PointerSharedManaged(i), field2.PointerSharedManaged(i), field3.PointerSharedManaged(i), field4.PointerSharedManaged(i), field5.PointerSharedManaged(i), field6.PointerSharedManaged(i), field7.PointerSharedManaged(i), field8.PointerSharedManaged(i), field9.PointerSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSparseManaged(i), field1.PointerSparseManaged(i), field2.PointerSparseManaged(i), field3.PointerSparseManaged(i), field4.PointerSparseManaged(i), field5.PointerSparseManaged(i), field6.PointerSparseManaged(i), field7.PointerSparseManaged(i), field8.PointerSparseManaged(i), field9.PointerSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSparseSharedManaged(i), field1.PointerSparseSharedManaged(i), field2.PointerSparseSharedManaged(i), field3.PointerSparseSharedManaged(i), field4.PointerSparseSharedManaged(i), field5.PointerSparseSharedManaged(i), field6.PointerSparseSharedManaged(i), field7.PointerSparseSharedManaged(i), field8.PointerSparseSharedManaged(i), field9.PointerSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 }
\ No newline at end of file
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/Invoker/Find/Iterator/T11.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/Invoker/Find/Iterator/T11.g.cs
index e4dc67f8..52aa5ec2 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/Invoker/Find/Iterator/T11.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/Invoker/Find/Iterator/T11.g.cs
@@ -1,5 +1,7 @@
 // Find/Iterator/T11.g.cs
 // File was auto-generated by /_/src/Flecs.NET.Codegen/Generators/Invoker.cs
+using System;
+using System.Runtime.CompilerServices;
 using Flecs.NET.Utilities;
 using static Flecs.NET.Bindings.flecs;
 
@@ -17,25 +19,135 @@ public static Entity Find<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(Iter it,
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8); byte* pointer9 = (byte*)it.GetPointer<T9>(9); byte* pointer10 = (byte*)it.GetPointer<T10>(10);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8); int step9 = it.Step<T9>(9); int step10 = it.Step<T10>(10);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8); FieldData<T9> field9 = it.GetFieldData<T9>(9); FieldData<T10> field10 = it.GetFieldData<T10>(10);
+        IterationTechnique flags = it.GetIterationTechnique(11);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8], pointer9 = &pointer9[step9], pointer10 = &pointer10[step10])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>() || RuntimeHelpers.IsReferenceOrContainsReferences<T9>() || RuntimeHelpers.IsReferenceOrContainsReferences<T10>())
         {
-            if (!callback(ref Managed.GetTypeRef<T0>(pointer0), ref Managed.GetTypeRef<T1>(pointer1), ref Managed.GetTypeRef<T2>(pointer2), ref Managed.GetTypeRef<T3>(pointer3), ref Managed.GetTypeRef<T4>(pointer4), ref Managed.GetTypeRef<T5>(pointer5), ref Managed.GetTypeRef<T6>(pointer6), ref Managed.GetTypeRef<T7>(pointer7), ref Managed.GetTypeRef<T8>(pointer8), ref Managed.GetTypeRef<T9>(pointer9), ref Managed.GetTypeRef<T10>(pointer10)))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, Ecs.FindRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefUnmanaged(i), ref field1.RefUnmanaged(i), ref field2.RefUnmanaged(i), ref field3.RefUnmanaged(i), ref field4.RefUnmanaged(i), ref field5.RefUnmanaged(i), ref field6.RefUnmanaged(i), ref field7.RefUnmanaged(i), ref field8.RefUnmanaged(i), ref field9.RefUnmanaged(i), ref field10.RefUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, Ecs.FindRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSharedUnmanaged(i), ref field1.RefSharedUnmanaged(i), ref field2.RefSharedUnmanaged(i), ref field3.RefSharedUnmanaged(i), ref field4.RefSharedUnmanaged(i), ref field5.RefSharedUnmanaged(i), ref field6.RefSharedUnmanaged(i), ref field7.RefSharedUnmanaged(i), ref field8.RefSharedUnmanaged(i), ref field9.RefSharedUnmanaged(i), ref field10.RefSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, Ecs.FindRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSparseUnmanaged(i), ref field1.RefSparseUnmanaged(i), ref field2.RefSparseUnmanaged(i), ref field3.RefSparseUnmanaged(i), ref field4.RefSparseUnmanaged(i), ref field5.RefSparseUnmanaged(i), ref field6.RefSparseUnmanaged(i), ref field7.RefSparseUnmanaged(i), ref field8.RefSparseUnmanaged(i), ref field9.RefSparseUnmanaged(i), ref field10.RefSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, Ecs.FindRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSparseSharedUnmanaged(i), ref field1.RefSparseSharedUnmanaged(i), ref field2.RefSparseSharedUnmanaged(i), ref field3.RefSparseSharedUnmanaged(i), ref field4.RefSparseSharedUnmanaged(i), ref field5.RefSparseSharedUnmanaged(i), ref field6.RefSparseSharedUnmanaged(i), ref field7.RefSparseSharedUnmanaged(i), ref field8.RefSparseSharedUnmanaged(i), ref field9.RefSparseSharedUnmanaged(i), ref field10.RefSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, Ecs.FindRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefManaged(i), ref field1.RefManaged(i), ref field2.RefManaged(i), ref field3.RefManaged(i), ref field4.RefManaged(i), ref field5.RefManaged(i), ref field6.RefManaged(i), ref field7.RefManaged(i), ref field8.RefManaged(i), ref field9.RefManaged(i), ref field10.RefManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, Ecs.FindRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSharedManaged(i), ref field1.RefSharedManaged(i), ref field2.RefSharedManaged(i), ref field3.RefSharedManaged(i), ref field4.RefSharedManaged(i), ref field5.RefSharedManaged(i), ref field6.RefSharedManaged(i), ref field7.RefSharedManaged(i), ref field8.RefSharedManaged(i), ref field9.RefSharedManaged(i), ref field10.RefSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, Ecs.FindRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSparseManaged(i), ref field1.RefSparseManaged(i), ref field2.RefSparseManaged(i), ref field3.RefSparseManaged(i), ref field4.RefSparseManaged(i), ref field5.RefSparseManaged(i), ref field6.RefSparseManaged(i), ref field7.RefSparseManaged(i), ref field8.RefSparseManaged(i), ref field9.RefSparseManaged(i), ref field10.RefSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, Ecs.FindRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSparseSharedManaged(i), ref field1.RefSparseSharedManaged(i), ref field2.RefSparseSharedManaged(i), ref field3.RefSparseSharedManaged(i), ref field4.RefSparseSharedManaged(i), ref field5.RefSparseSharedManaged(i), ref field6.RefSparseSharedManaged(i), ref field7.RefSparseSharedManaged(i), ref field8.RefSparseSharedManaged(i), ref field9.RefSparseSharedManaged(i), ref field10.RefSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 
     /// <summary>
@@ -48,25 +160,135 @@ public static Entity Find<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(Iter it,
     {
         int count = it.Handle->count; Ecs.Assert(it.Handle->count > 0, "No entities returned, use Iter() or Each() without the entity argument instead.");
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8); byte* pointer9 = (byte*)it.GetPointer<T9>(9); byte* pointer10 = (byte*)it.GetPointer<T10>(10);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8); int step9 = it.Step<T9>(9); int step10 = it.Step<T10>(10);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8); FieldData<T9> field9 = it.GetFieldData<T9>(9); FieldData<T10> field10 = it.GetFieldData<T10>(10);
+        IterationTechnique flags = it.GetIterationTechnique(11);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8], pointer9 = &pointer9[step9], pointer10 = &pointer10[step10])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>() || RuntimeHelpers.IsReferenceOrContainsReferences<T9>() || RuntimeHelpers.IsReferenceOrContainsReferences<T10>())
         {
-            if (!callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref Managed.GetTypeRef<T0>(pointer0), ref Managed.GetTypeRef<T1>(pointer1), ref Managed.GetTypeRef<T2>(pointer2), ref Managed.GetTypeRef<T3>(pointer3), ref Managed.GetTypeRef<T4>(pointer4), ref Managed.GetTypeRef<T5>(pointer5), ref Managed.GetTypeRef<T6>(pointer6), ref Managed.GetTypeRef<T7>(pointer7), ref Managed.GetTypeRef<T8>(pointer8), ref Managed.GetTypeRef<T9>(pointer9), ref Managed.GetTypeRef<T10>(pointer10)))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefUnmanaged(i), ref field1.RefUnmanaged(i), ref field2.RefUnmanaged(i), ref field3.RefUnmanaged(i), ref field4.RefUnmanaged(i), ref field5.RefUnmanaged(i), ref field6.RefUnmanaged(i), ref field7.RefUnmanaged(i), ref field8.RefUnmanaged(i), ref field9.RefUnmanaged(i), ref field10.RefUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSharedUnmanaged(i), ref field1.RefSharedUnmanaged(i), ref field2.RefSharedUnmanaged(i), ref field3.RefSharedUnmanaged(i), ref field4.RefSharedUnmanaged(i), ref field5.RefSharedUnmanaged(i), ref field6.RefSharedUnmanaged(i), ref field7.RefSharedUnmanaged(i), ref field8.RefSharedUnmanaged(i), ref field9.RefSharedUnmanaged(i), ref field10.RefSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseUnmanaged(i), ref field1.RefSparseUnmanaged(i), ref field2.RefSparseUnmanaged(i), ref field3.RefSparseUnmanaged(i), ref field4.RefSparseUnmanaged(i), ref field5.RefSparseUnmanaged(i), ref field6.RefSparseUnmanaged(i), ref field7.RefSparseUnmanaged(i), ref field8.RefSparseUnmanaged(i), ref field9.RefSparseUnmanaged(i), ref field10.RefSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseSharedUnmanaged(i), ref field1.RefSparseSharedUnmanaged(i), ref field2.RefSparseSharedUnmanaged(i), ref field3.RefSparseSharedUnmanaged(i), ref field4.RefSparseSharedUnmanaged(i), ref field5.RefSparseSharedUnmanaged(i), ref field6.RefSparseSharedUnmanaged(i), ref field7.RefSparseSharedUnmanaged(i), ref field8.RefSparseSharedUnmanaged(i), ref field9.RefSparseSharedUnmanaged(i), ref field10.RefSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefManaged(i), ref field1.RefManaged(i), ref field2.RefManaged(i), ref field3.RefManaged(i), ref field4.RefManaged(i), ref field5.RefManaged(i), ref field6.RefManaged(i), ref field7.RefManaged(i), ref field8.RefManaged(i), ref field9.RefManaged(i), ref field10.RefManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSharedManaged(i), ref field1.RefSharedManaged(i), ref field2.RefSharedManaged(i), ref field3.RefSharedManaged(i), ref field4.RefSharedManaged(i), ref field5.RefSharedManaged(i), ref field6.RefSharedManaged(i), ref field7.RefSharedManaged(i), ref field8.RefSharedManaged(i), ref field9.RefSharedManaged(i), ref field10.RefSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseManaged(i), ref field1.RefSparseManaged(i), ref field2.RefSparseManaged(i), ref field3.RefSparseManaged(i), ref field4.RefSparseManaged(i), ref field5.RefSparseManaged(i), ref field6.RefSparseManaged(i), ref field7.RefSparseManaged(i), ref field8.RefSparseManaged(i), ref field9.RefSparseManaged(i), ref field10.RefSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseSharedManaged(i), ref field1.RefSparseSharedManaged(i), ref field2.RefSparseSharedManaged(i), ref field3.RefSparseSharedManaged(i), ref field4.RefSparseSharedManaged(i), ref field5.RefSparseSharedManaged(i), ref field6.RefSparseSharedManaged(i), ref field7.RefSparseSharedManaged(i), ref field8.RefSparseSharedManaged(i), ref field9.RefSparseSharedManaged(i), ref field10.RefSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 
     /// <summary>
@@ -79,25 +301,135 @@ public static Entity Find<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(Iter it,
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8); byte* pointer9 = (byte*)it.GetPointer<T9>(9); byte* pointer10 = (byte*)it.GetPointer<T10>(10);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8); int step9 = it.Step<T9>(9); int step10 = it.Step<T10>(10);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8); FieldData<T9> field9 = it.GetFieldData<T9>(9); FieldData<T10> field10 = it.GetFieldData<T10>(10);
+        IterationTechnique flags = it.GetIterationTechnique(11);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8], pointer9 = &pointer9[step9], pointer10 = &pointer10[step10])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>() || RuntimeHelpers.IsReferenceOrContainsReferences<T9>() || RuntimeHelpers.IsReferenceOrContainsReferences<T10>())
         {
-            if (!callback(it, i, ref Managed.GetTypeRef<T0>(pointer0), ref Managed.GetTypeRef<T1>(pointer1), ref Managed.GetTypeRef<T2>(pointer2), ref Managed.GetTypeRef<T3>(pointer3), ref Managed.GetTypeRef<T4>(pointer4), ref Managed.GetTypeRef<T5>(pointer5), ref Managed.GetTypeRef<T6>(pointer6), ref Managed.GetTypeRef<T7>(pointer7), ref Managed.GetTypeRef<T8>(pointer8), ref Managed.GetTypeRef<T9>(pointer9), ref Managed.GetTypeRef<T10>(pointer10)))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, Ecs.FindIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefUnmanaged(i), ref field1.RefUnmanaged(i), ref field2.RefUnmanaged(i), ref field3.RefUnmanaged(i), ref field4.RefUnmanaged(i), ref field5.RefUnmanaged(i), ref field6.RefUnmanaged(i), ref field7.RefUnmanaged(i), ref field8.RefUnmanaged(i), ref field9.RefUnmanaged(i), ref field10.RefUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, Ecs.FindIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSharedUnmanaged(i), ref field1.RefSharedUnmanaged(i), ref field2.RefSharedUnmanaged(i), ref field3.RefSharedUnmanaged(i), ref field4.RefSharedUnmanaged(i), ref field5.RefSharedUnmanaged(i), ref field6.RefSharedUnmanaged(i), ref field7.RefSharedUnmanaged(i), ref field8.RefSharedUnmanaged(i), ref field9.RefSharedUnmanaged(i), ref field10.RefSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, Ecs.FindIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSparseUnmanaged(i), ref field1.RefSparseUnmanaged(i), ref field2.RefSparseUnmanaged(i), ref field3.RefSparseUnmanaged(i), ref field4.RefSparseUnmanaged(i), ref field5.RefSparseUnmanaged(i), ref field6.RefSparseUnmanaged(i), ref field7.RefSparseUnmanaged(i), ref field8.RefSparseUnmanaged(i), ref field9.RefSparseUnmanaged(i), ref field10.RefSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, Ecs.FindIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSparseSharedUnmanaged(i), ref field1.RefSparseSharedUnmanaged(i), ref field2.RefSparseSharedUnmanaged(i), ref field3.RefSparseSharedUnmanaged(i), ref field4.RefSparseSharedUnmanaged(i), ref field5.RefSparseSharedUnmanaged(i), ref field6.RefSparseSharedUnmanaged(i), ref field7.RefSparseSharedUnmanaged(i), ref field8.RefSparseSharedUnmanaged(i), ref field9.RefSparseSharedUnmanaged(i), ref field10.RefSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, Ecs.FindIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefManaged(i), ref field1.RefManaged(i), ref field2.RefManaged(i), ref field3.RefManaged(i), ref field4.RefManaged(i), ref field5.RefManaged(i), ref field6.RefManaged(i), ref field7.RefManaged(i), ref field8.RefManaged(i), ref field9.RefManaged(i), ref field10.RefManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, Ecs.FindIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSharedManaged(i), ref field1.RefSharedManaged(i), ref field2.RefSharedManaged(i), ref field3.RefSharedManaged(i), ref field4.RefSharedManaged(i), ref field5.RefSharedManaged(i), ref field6.RefSharedManaged(i), ref field7.RefSharedManaged(i), ref field8.RefSharedManaged(i), ref field9.RefSharedManaged(i), ref field10.RefSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, Ecs.FindIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSparseManaged(i), ref field1.RefSparseManaged(i), ref field2.RefSparseManaged(i), ref field3.RefSparseManaged(i), ref field4.RefSparseManaged(i), ref field5.RefSparseManaged(i), ref field6.RefSparseManaged(i), ref field7.RefSparseManaged(i), ref field8.RefSparseManaged(i), ref field9.RefSparseManaged(i), ref field10.RefSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, Ecs.FindIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSparseSharedManaged(i), ref field1.RefSparseSharedManaged(i), ref field2.RefSparseSharedManaged(i), ref field3.RefSparseSharedManaged(i), ref field4.RefSparseSharedManaged(i), ref field5.RefSparseSharedManaged(i), ref field6.RefSparseSharedManaged(i), ref field7.RefSparseSharedManaged(i), ref field8.RefSparseSharedManaged(i), ref field9.RefSparseSharedManaged(i), ref field10.RefSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 
     /// <summary>
@@ -110,25 +442,135 @@ public static Entity Find<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(Iter it,
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8); byte* pointer9 = (byte*)it.GetPointer<T9>(9); byte* pointer10 = (byte*)it.GetPointer<T10>(10);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8); int step9 = it.Step<T9>(9); int step10 = it.Step<T10>(10);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8); FieldData<T9> field9 = it.GetFieldData<T9>(9); FieldData<T10> field10 = it.GetFieldData<T10>(10);
+        IterationTechnique flags = it.GetIterationTechnique(11);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8], pointer9 = &pointer9[step9], pointer10 = &pointer10[step10])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>() || RuntimeHelpers.IsReferenceOrContainsReferences<T9>() || RuntimeHelpers.IsReferenceOrContainsReferences<T10>())
         {
-            if (!callback(ref Managed.GetTypeRef<T0>(pointer0), ref Managed.GetTypeRef<T1>(pointer1), ref Managed.GetTypeRef<T2>(pointer2), ref Managed.GetTypeRef<T3>(pointer3), ref Managed.GetTypeRef<T4>(pointer4), ref Managed.GetTypeRef<T5>(pointer5), ref Managed.GetTypeRef<T6>(pointer6), ref Managed.GetTypeRef<T7>(pointer7), ref Managed.GetTypeRef<T8>(pointer8), ref Managed.GetTypeRef<T9>(pointer9), ref Managed.GetTypeRef<T10>(pointer10)))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefUnmanaged(i), ref field1.RefUnmanaged(i), ref field2.RefUnmanaged(i), ref field3.RefUnmanaged(i), ref field4.RefUnmanaged(i), ref field5.RefUnmanaged(i), ref field6.RefUnmanaged(i), ref field7.RefUnmanaged(i), ref field8.RefUnmanaged(i), ref field9.RefUnmanaged(i), ref field10.RefUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSharedUnmanaged(i), ref field1.RefSharedUnmanaged(i), ref field2.RefSharedUnmanaged(i), ref field3.RefSharedUnmanaged(i), ref field4.RefSharedUnmanaged(i), ref field5.RefSharedUnmanaged(i), ref field6.RefSharedUnmanaged(i), ref field7.RefSharedUnmanaged(i), ref field8.RefSharedUnmanaged(i), ref field9.RefSharedUnmanaged(i), ref field10.RefSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSparseUnmanaged(i), ref field1.RefSparseUnmanaged(i), ref field2.RefSparseUnmanaged(i), ref field3.RefSparseUnmanaged(i), ref field4.RefSparseUnmanaged(i), ref field5.RefSparseUnmanaged(i), ref field6.RefSparseUnmanaged(i), ref field7.RefSparseUnmanaged(i), ref field8.RefSparseUnmanaged(i), ref field9.RefSparseUnmanaged(i), ref field10.RefSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSparseSharedUnmanaged(i), ref field1.RefSparseSharedUnmanaged(i), ref field2.RefSparseSharedUnmanaged(i), ref field3.RefSparseSharedUnmanaged(i), ref field4.RefSparseSharedUnmanaged(i), ref field5.RefSparseSharedUnmanaged(i), ref field6.RefSparseSharedUnmanaged(i), ref field7.RefSparseSharedUnmanaged(i), ref field8.RefSparseSharedUnmanaged(i), ref field9.RefSparseSharedUnmanaged(i), ref field10.RefSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefManaged(i), ref field1.RefManaged(i), ref field2.RefManaged(i), ref field3.RefManaged(i), ref field4.RefManaged(i), ref field5.RefManaged(i), ref field6.RefManaged(i), ref field7.RefManaged(i), ref field8.RefManaged(i), ref field9.RefManaged(i), ref field10.RefManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSharedManaged(i), ref field1.RefSharedManaged(i), ref field2.RefSharedManaged(i), ref field3.RefSharedManaged(i), ref field4.RefSharedManaged(i), ref field5.RefSharedManaged(i), ref field6.RefSharedManaged(i), ref field7.RefSharedManaged(i), ref field8.RefSharedManaged(i), ref field9.RefSharedManaged(i), ref field10.RefSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSparseManaged(i), ref field1.RefSparseManaged(i), ref field2.RefSparseManaged(i), ref field3.RefSparseManaged(i), ref field4.RefSparseManaged(i), ref field5.RefSparseManaged(i), ref field6.RefSparseManaged(i), ref field7.RefSparseManaged(i), ref field8.RefSparseManaged(i), ref field9.RefSparseManaged(i), ref field10.RefSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSparseSharedManaged(i), ref field1.RefSparseSharedManaged(i), ref field2.RefSparseSharedManaged(i), ref field3.RefSparseSharedManaged(i), ref field4.RefSparseSharedManaged(i), ref field5.RefSparseSharedManaged(i), ref field6.RefSparseSharedManaged(i), ref field7.RefSparseSharedManaged(i), ref field8.RefSparseSharedManaged(i), ref field9.RefSparseSharedManaged(i), ref field10.RefSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 
     /// <summary>
@@ -141,25 +583,135 @@ public static Entity Find<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(Iter it,
     {
         int count = it.Handle->count; Ecs.Assert(it.Handle->count > 0, "No entities returned, use Iter() or Each() without the entity argument instead.");
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8); byte* pointer9 = (byte*)it.GetPointer<T9>(9); byte* pointer10 = (byte*)it.GetPointer<T10>(10);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8); int step9 = it.Step<T9>(9); int step10 = it.Step<T10>(10);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8); FieldData<T9> field9 = it.GetFieldData<T9>(9); FieldData<T10> field10 = it.GetFieldData<T10>(10);
+        IterationTechnique flags = it.GetIterationTechnique(11);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8], pointer9 = &pointer9[step9], pointer10 = &pointer10[step10])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>() || RuntimeHelpers.IsReferenceOrContainsReferences<T9>() || RuntimeHelpers.IsReferenceOrContainsReferences<T10>())
         {
-            if (!callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref Managed.GetTypeRef<T0>(pointer0), ref Managed.GetTypeRef<T1>(pointer1), ref Managed.GetTypeRef<T2>(pointer2), ref Managed.GetTypeRef<T3>(pointer3), ref Managed.GetTypeRef<T4>(pointer4), ref Managed.GetTypeRef<T5>(pointer5), ref Managed.GetTypeRef<T6>(pointer6), ref Managed.GetTypeRef<T7>(pointer7), ref Managed.GetTypeRef<T8>(pointer8), ref Managed.GetTypeRef<T9>(pointer9), ref Managed.GetTypeRef<T10>(pointer10)))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefUnmanaged(i), ref field1.RefUnmanaged(i), ref field2.RefUnmanaged(i), ref field3.RefUnmanaged(i), ref field4.RefUnmanaged(i), ref field5.RefUnmanaged(i), ref field6.RefUnmanaged(i), ref field7.RefUnmanaged(i), ref field8.RefUnmanaged(i), ref field9.RefUnmanaged(i), ref field10.RefUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSharedUnmanaged(i), ref field1.RefSharedUnmanaged(i), ref field2.RefSharedUnmanaged(i), ref field3.RefSharedUnmanaged(i), ref field4.RefSharedUnmanaged(i), ref field5.RefSharedUnmanaged(i), ref field6.RefSharedUnmanaged(i), ref field7.RefSharedUnmanaged(i), ref field8.RefSharedUnmanaged(i), ref field9.RefSharedUnmanaged(i), ref field10.RefSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseUnmanaged(i), ref field1.RefSparseUnmanaged(i), ref field2.RefSparseUnmanaged(i), ref field3.RefSparseUnmanaged(i), ref field4.RefSparseUnmanaged(i), ref field5.RefSparseUnmanaged(i), ref field6.RefSparseUnmanaged(i), ref field7.RefSparseUnmanaged(i), ref field8.RefSparseUnmanaged(i), ref field9.RefSparseUnmanaged(i), ref field10.RefSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseSharedUnmanaged(i), ref field1.RefSparseSharedUnmanaged(i), ref field2.RefSparseSharedUnmanaged(i), ref field3.RefSparseSharedUnmanaged(i), ref field4.RefSparseSharedUnmanaged(i), ref field5.RefSparseSharedUnmanaged(i), ref field6.RefSparseSharedUnmanaged(i), ref field7.RefSparseSharedUnmanaged(i), ref field8.RefSparseSharedUnmanaged(i), ref field9.RefSparseSharedUnmanaged(i), ref field10.RefSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefManaged(i), ref field1.RefManaged(i), ref field2.RefManaged(i), ref field3.RefManaged(i), ref field4.RefManaged(i), ref field5.RefManaged(i), ref field6.RefManaged(i), ref field7.RefManaged(i), ref field8.RefManaged(i), ref field9.RefManaged(i), ref field10.RefManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSharedManaged(i), ref field1.RefSharedManaged(i), ref field2.RefSharedManaged(i), ref field3.RefSharedManaged(i), ref field4.RefSharedManaged(i), ref field5.RefSharedManaged(i), ref field6.RefSharedManaged(i), ref field7.RefSharedManaged(i), ref field8.RefSharedManaged(i), ref field9.RefSharedManaged(i), ref field10.RefSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseManaged(i), ref field1.RefSparseManaged(i), ref field2.RefSparseManaged(i), ref field3.RefSparseManaged(i), ref field4.RefSparseManaged(i), ref field5.RefSparseManaged(i), ref field6.RefSparseManaged(i), ref field7.RefSparseManaged(i), ref field8.RefSparseManaged(i), ref field9.RefSparseManaged(i), ref field10.RefSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseSharedManaged(i), ref field1.RefSparseSharedManaged(i), ref field2.RefSparseSharedManaged(i), ref field3.RefSparseSharedManaged(i), ref field4.RefSparseSharedManaged(i), ref field5.RefSparseSharedManaged(i), ref field6.RefSparseSharedManaged(i), ref field7.RefSparseSharedManaged(i), ref field8.RefSparseSharedManaged(i), ref field9.RefSparseSharedManaged(i), ref field10.RefSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 
     /// <summary>
@@ -172,25 +724,135 @@ public static Entity Find<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(Iter it,
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8); byte* pointer9 = (byte*)it.GetPointer<T9>(9); byte* pointer10 = (byte*)it.GetPointer<T10>(10);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8); int step9 = it.Step<T9>(9); int step10 = it.Step<T10>(10);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8); FieldData<T9> field9 = it.GetFieldData<T9>(9); FieldData<T10> field10 = it.GetFieldData<T10>(10);
+        IterationTechnique flags = it.GetIterationTechnique(11);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8], pointer9 = &pointer9[step9], pointer10 = &pointer10[step10])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>() || RuntimeHelpers.IsReferenceOrContainsReferences<T9>() || RuntimeHelpers.IsReferenceOrContainsReferences<T10>())
         {
-            if (!callback(it, i, ref Managed.GetTypeRef<T0>(pointer0), ref Managed.GetTypeRef<T1>(pointer1), ref Managed.GetTypeRef<T2>(pointer2), ref Managed.GetTypeRef<T3>(pointer3), ref Managed.GetTypeRef<T4>(pointer4), ref Managed.GetTypeRef<T5>(pointer5), ref Managed.GetTypeRef<T6>(pointer6), ref Managed.GetTypeRef<T7>(pointer7), ref Managed.GetTypeRef<T8>(pointer8), ref Managed.GetTypeRef<T9>(pointer9), ref Managed.GetTypeRef<T10>(pointer10)))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefUnmanaged(i), ref field1.RefUnmanaged(i), ref field2.RefUnmanaged(i), ref field3.RefUnmanaged(i), ref field4.RefUnmanaged(i), ref field5.RefUnmanaged(i), ref field6.RefUnmanaged(i), ref field7.RefUnmanaged(i), ref field8.RefUnmanaged(i), ref field9.RefUnmanaged(i), ref field10.RefUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSharedUnmanaged(i), ref field1.RefSharedUnmanaged(i), ref field2.RefSharedUnmanaged(i), ref field3.RefSharedUnmanaged(i), ref field4.RefSharedUnmanaged(i), ref field5.RefSharedUnmanaged(i), ref field6.RefSharedUnmanaged(i), ref field7.RefSharedUnmanaged(i), ref field8.RefSharedUnmanaged(i), ref field9.RefSharedUnmanaged(i), ref field10.RefSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSparseUnmanaged(i), ref field1.RefSparseUnmanaged(i), ref field2.RefSparseUnmanaged(i), ref field3.RefSparseUnmanaged(i), ref field4.RefSparseUnmanaged(i), ref field5.RefSparseUnmanaged(i), ref field6.RefSparseUnmanaged(i), ref field7.RefSparseUnmanaged(i), ref field8.RefSparseUnmanaged(i), ref field9.RefSparseUnmanaged(i), ref field10.RefSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSparseSharedUnmanaged(i), ref field1.RefSparseSharedUnmanaged(i), ref field2.RefSparseSharedUnmanaged(i), ref field3.RefSparseSharedUnmanaged(i), ref field4.RefSparseSharedUnmanaged(i), ref field5.RefSparseSharedUnmanaged(i), ref field6.RefSparseSharedUnmanaged(i), ref field7.RefSparseSharedUnmanaged(i), ref field8.RefSparseSharedUnmanaged(i), ref field9.RefSparseSharedUnmanaged(i), ref field10.RefSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefManaged(i), ref field1.RefManaged(i), ref field2.RefManaged(i), ref field3.RefManaged(i), ref field4.RefManaged(i), ref field5.RefManaged(i), ref field6.RefManaged(i), ref field7.RefManaged(i), ref field8.RefManaged(i), ref field9.RefManaged(i), ref field10.RefManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSharedManaged(i), ref field1.RefSharedManaged(i), ref field2.RefSharedManaged(i), ref field3.RefSharedManaged(i), ref field4.RefSharedManaged(i), ref field5.RefSharedManaged(i), ref field6.RefSharedManaged(i), ref field7.RefSharedManaged(i), ref field8.RefSharedManaged(i), ref field9.RefSharedManaged(i), ref field10.RefSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSparseManaged(i), ref field1.RefSparseManaged(i), ref field2.RefSparseManaged(i), ref field3.RefSparseManaged(i), ref field4.RefSparseManaged(i), ref field5.RefSparseManaged(i), ref field6.RefSparseManaged(i), ref field7.RefSparseManaged(i), ref field8.RefSparseManaged(i), ref field9.RefSparseManaged(i), ref field10.RefSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSparseSharedManaged(i), ref field1.RefSparseSharedManaged(i), ref field2.RefSparseSharedManaged(i), ref field3.RefSparseSharedManaged(i), ref field4.RefSparseSharedManaged(i), ref field5.RefSparseSharedManaged(i), ref field6.RefSparseSharedManaged(i), ref field7.RefSparseSharedManaged(i), ref field8.RefSparseSharedManaged(i), ref field9.RefSparseSharedManaged(i), ref field10.RefSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 
     /// <summary>
@@ -203,25 +865,135 @@ public static Entity Find<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(Iter it,
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8); byte* pointer9 = (byte*)it.GetPointer<T9>(9); byte* pointer10 = (byte*)it.GetPointer<T10>(10);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8); int step9 = it.Step<T9>(9); int step10 = it.Step<T10>(10);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8); FieldData<T9> field9 = it.GetFieldData<T9>(9); FieldData<T10> field10 = it.GetFieldData<T10>(10);
+        IterationTechnique flags = it.GetIterationTechnique(11);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8], pointer9 = &pointer9[step9], pointer10 = &pointer10[step10])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>() || RuntimeHelpers.IsReferenceOrContainsReferences<T9>() || RuntimeHelpers.IsReferenceOrContainsReferences<T10>())
         {
-            if (!callback((T0*)pointer0, (T1*)pointer1, (T2*)pointer2, (T3*)pointer3, (T4*)pointer4, (T5*)pointer5, (T6*)pointer6, (T7*)pointer7, (T8*)pointer8, (T9*)pointer9, (T10*)pointer10))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, Ecs.FindPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerUnmanaged(i), field1.PointerUnmanaged(i), field2.PointerUnmanaged(i), field3.PointerUnmanaged(i), field4.PointerUnmanaged(i), field5.PointerUnmanaged(i), field6.PointerUnmanaged(i), field7.PointerUnmanaged(i), field8.PointerUnmanaged(i), field9.PointerUnmanaged(i), field10.PointerUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, Ecs.FindPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSharedUnmanaged(i), field1.PointerSharedUnmanaged(i), field2.PointerSharedUnmanaged(i), field3.PointerSharedUnmanaged(i), field4.PointerSharedUnmanaged(i), field5.PointerSharedUnmanaged(i), field6.PointerSharedUnmanaged(i), field7.PointerSharedUnmanaged(i), field8.PointerSharedUnmanaged(i), field9.PointerSharedUnmanaged(i), field10.PointerSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, Ecs.FindPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSparseUnmanaged(i), field1.PointerSparseUnmanaged(i), field2.PointerSparseUnmanaged(i), field3.PointerSparseUnmanaged(i), field4.PointerSparseUnmanaged(i), field5.PointerSparseUnmanaged(i), field6.PointerSparseUnmanaged(i), field7.PointerSparseUnmanaged(i), field8.PointerSparseUnmanaged(i), field9.PointerSparseUnmanaged(i), field10.PointerSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, Ecs.FindPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSparseSharedUnmanaged(i), field1.PointerSparseSharedUnmanaged(i), field2.PointerSparseSharedUnmanaged(i), field3.PointerSparseSharedUnmanaged(i), field4.PointerSparseSharedUnmanaged(i), field5.PointerSparseSharedUnmanaged(i), field6.PointerSparseSharedUnmanaged(i), field7.PointerSparseSharedUnmanaged(i), field8.PointerSparseSharedUnmanaged(i), field9.PointerSparseSharedUnmanaged(i), field10.PointerSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, Ecs.FindPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerManaged(i), field1.PointerManaged(i), field2.PointerManaged(i), field3.PointerManaged(i), field4.PointerManaged(i), field5.PointerManaged(i), field6.PointerManaged(i), field7.PointerManaged(i), field8.PointerManaged(i), field9.PointerManaged(i), field10.PointerManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, Ecs.FindPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSharedManaged(i), field1.PointerSharedManaged(i), field2.PointerSharedManaged(i), field3.PointerSharedManaged(i), field4.PointerSharedManaged(i), field5.PointerSharedManaged(i), field6.PointerSharedManaged(i), field7.PointerSharedManaged(i), field8.PointerSharedManaged(i), field9.PointerSharedManaged(i), field10.PointerSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, Ecs.FindPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSparseManaged(i), field1.PointerSparseManaged(i), field2.PointerSparseManaged(i), field3.PointerSparseManaged(i), field4.PointerSparseManaged(i), field5.PointerSparseManaged(i), field6.PointerSparseManaged(i), field7.PointerSparseManaged(i), field8.PointerSparseManaged(i), field9.PointerSparseManaged(i), field10.PointerSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, Ecs.FindPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSparseSharedManaged(i), field1.PointerSparseSharedManaged(i), field2.PointerSparseSharedManaged(i), field3.PointerSparseSharedManaged(i), field4.PointerSparseSharedManaged(i), field5.PointerSparseSharedManaged(i), field6.PointerSparseSharedManaged(i), field7.PointerSparseSharedManaged(i), field8.PointerSparseSharedManaged(i), field9.PointerSparseSharedManaged(i), field10.PointerSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 
     /// <summary>
@@ -234,25 +1006,135 @@ public static Entity Find<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(Iter it,
     {
         int count = it.Handle->count; Ecs.Assert(it.Handle->count > 0, "No entities returned, use Iter() or Each() without the entity argument instead.");
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8); byte* pointer9 = (byte*)it.GetPointer<T9>(9); byte* pointer10 = (byte*)it.GetPointer<T10>(10);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8); int step9 = it.Step<T9>(9); int step10 = it.Step<T10>(10);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8); FieldData<T9> field9 = it.GetFieldData<T9>(9); FieldData<T10> field10 = it.GetFieldData<T10>(10);
+        IterationTechnique flags = it.GetIterationTechnique(11);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8], pointer9 = &pointer9[step9], pointer10 = &pointer10[step10])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>() || RuntimeHelpers.IsReferenceOrContainsReferences<T9>() || RuntimeHelpers.IsReferenceOrContainsReferences<T10>())
         {
-            if (!callback(new Entity(it.Handle->world, it.Handle->entities[i]), (T0*)pointer0, (T1*)pointer1, (T2*)pointer2, (T3*)pointer3, (T4*)pointer4, (T5*)pointer5, (T6*)pointer6, (T7*)pointer7, (T8*)pointer8, (T9*)pointer9, (T10*)pointer10))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerUnmanaged(i), field1.PointerUnmanaged(i), field2.PointerUnmanaged(i), field3.PointerUnmanaged(i), field4.PointerUnmanaged(i), field5.PointerUnmanaged(i), field6.PointerUnmanaged(i), field7.PointerUnmanaged(i), field8.PointerUnmanaged(i), field9.PointerUnmanaged(i), field10.PointerUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSharedUnmanaged(i), field1.PointerSharedUnmanaged(i), field2.PointerSharedUnmanaged(i), field3.PointerSharedUnmanaged(i), field4.PointerSharedUnmanaged(i), field5.PointerSharedUnmanaged(i), field6.PointerSharedUnmanaged(i), field7.PointerSharedUnmanaged(i), field8.PointerSharedUnmanaged(i), field9.PointerSharedUnmanaged(i), field10.PointerSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseUnmanaged(i), field1.PointerSparseUnmanaged(i), field2.PointerSparseUnmanaged(i), field3.PointerSparseUnmanaged(i), field4.PointerSparseUnmanaged(i), field5.PointerSparseUnmanaged(i), field6.PointerSparseUnmanaged(i), field7.PointerSparseUnmanaged(i), field8.PointerSparseUnmanaged(i), field9.PointerSparseUnmanaged(i), field10.PointerSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseSharedUnmanaged(i), field1.PointerSparseSharedUnmanaged(i), field2.PointerSparseSharedUnmanaged(i), field3.PointerSparseSharedUnmanaged(i), field4.PointerSparseSharedUnmanaged(i), field5.PointerSparseSharedUnmanaged(i), field6.PointerSparseSharedUnmanaged(i), field7.PointerSparseSharedUnmanaged(i), field8.PointerSparseSharedUnmanaged(i), field9.PointerSparseSharedUnmanaged(i), field10.PointerSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerManaged(i), field1.PointerManaged(i), field2.PointerManaged(i), field3.PointerManaged(i), field4.PointerManaged(i), field5.PointerManaged(i), field6.PointerManaged(i), field7.PointerManaged(i), field8.PointerManaged(i), field9.PointerManaged(i), field10.PointerManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSharedManaged(i), field1.PointerSharedManaged(i), field2.PointerSharedManaged(i), field3.PointerSharedManaged(i), field4.PointerSharedManaged(i), field5.PointerSharedManaged(i), field6.PointerSharedManaged(i), field7.PointerSharedManaged(i), field8.PointerSharedManaged(i), field9.PointerSharedManaged(i), field10.PointerSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseManaged(i), field1.PointerSparseManaged(i), field2.PointerSparseManaged(i), field3.PointerSparseManaged(i), field4.PointerSparseManaged(i), field5.PointerSparseManaged(i), field6.PointerSparseManaged(i), field7.PointerSparseManaged(i), field8.PointerSparseManaged(i), field9.PointerSparseManaged(i), field10.PointerSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseSharedManaged(i), field1.PointerSparseSharedManaged(i), field2.PointerSparseSharedManaged(i), field3.PointerSparseSharedManaged(i), field4.PointerSparseSharedManaged(i), field5.PointerSparseSharedManaged(i), field6.PointerSparseSharedManaged(i), field7.PointerSparseSharedManaged(i), field8.PointerSparseSharedManaged(i), field9.PointerSparseSharedManaged(i), field10.PointerSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 
     /// <summary>
@@ -265,25 +1147,135 @@ public static Entity Find<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(Iter it,
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8); byte* pointer9 = (byte*)it.GetPointer<T9>(9); byte* pointer10 = (byte*)it.GetPointer<T10>(10);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8); int step9 = it.Step<T9>(9); int step10 = it.Step<T10>(10);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8); FieldData<T9> field9 = it.GetFieldData<T9>(9); FieldData<T10> field10 = it.GetFieldData<T10>(10);
+        IterationTechnique flags = it.GetIterationTechnique(11);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8], pointer9 = &pointer9[step9], pointer10 = &pointer10[step10])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>() || RuntimeHelpers.IsReferenceOrContainsReferences<T9>() || RuntimeHelpers.IsReferenceOrContainsReferences<T10>())
         {
-            if (!callback(it, i, (T0*)pointer0, (T1*)pointer1, (T2*)pointer2, (T3*)pointer3, (T4*)pointer4, (T5*)pointer5, (T6*)pointer6, (T7*)pointer7, (T8*)pointer8, (T9*)pointer9, (T10*)pointer10))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerUnmanaged(i), field1.PointerUnmanaged(i), field2.PointerUnmanaged(i), field3.PointerUnmanaged(i), field4.PointerUnmanaged(i), field5.PointerUnmanaged(i), field6.PointerUnmanaged(i), field7.PointerUnmanaged(i), field8.PointerUnmanaged(i), field9.PointerUnmanaged(i), field10.PointerUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSharedUnmanaged(i), field1.PointerSharedUnmanaged(i), field2.PointerSharedUnmanaged(i), field3.PointerSharedUnmanaged(i), field4.PointerSharedUnmanaged(i), field5.PointerSharedUnmanaged(i), field6.PointerSharedUnmanaged(i), field7.PointerSharedUnmanaged(i), field8.PointerSharedUnmanaged(i), field9.PointerSharedUnmanaged(i), field10.PointerSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSparseUnmanaged(i), field1.PointerSparseUnmanaged(i), field2.PointerSparseUnmanaged(i), field3.PointerSparseUnmanaged(i), field4.PointerSparseUnmanaged(i), field5.PointerSparseUnmanaged(i), field6.PointerSparseUnmanaged(i), field7.PointerSparseUnmanaged(i), field8.PointerSparseUnmanaged(i), field9.PointerSparseUnmanaged(i), field10.PointerSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSparseSharedUnmanaged(i), field1.PointerSparseSharedUnmanaged(i), field2.PointerSparseSharedUnmanaged(i), field3.PointerSparseSharedUnmanaged(i), field4.PointerSparseSharedUnmanaged(i), field5.PointerSparseSharedUnmanaged(i), field6.PointerSparseSharedUnmanaged(i), field7.PointerSparseSharedUnmanaged(i), field8.PointerSparseSharedUnmanaged(i), field9.PointerSparseSharedUnmanaged(i), field10.PointerSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerManaged(i), field1.PointerManaged(i), field2.PointerManaged(i), field3.PointerManaged(i), field4.PointerManaged(i), field5.PointerManaged(i), field6.PointerManaged(i), field7.PointerManaged(i), field8.PointerManaged(i), field9.PointerManaged(i), field10.PointerManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSharedManaged(i), field1.PointerSharedManaged(i), field2.PointerSharedManaged(i), field3.PointerSharedManaged(i), field4.PointerSharedManaged(i), field5.PointerSharedManaged(i), field6.PointerSharedManaged(i), field7.PointerSharedManaged(i), field8.PointerSharedManaged(i), field9.PointerSharedManaged(i), field10.PointerSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSparseManaged(i), field1.PointerSparseManaged(i), field2.PointerSparseManaged(i), field3.PointerSparseManaged(i), field4.PointerSparseManaged(i), field5.PointerSparseManaged(i), field6.PointerSparseManaged(i), field7.PointerSparseManaged(i), field8.PointerSparseManaged(i), field9.PointerSparseManaged(i), field10.PointerSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSparseSharedManaged(i), field1.PointerSparseSharedManaged(i), field2.PointerSparseSharedManaged(i), field3.PointerSparseSharedManaged(i), field4.PointerSparseSharedManaged(i), field5.PointerSparseSharedManaged(i), field6.PointerSparseSharedManaged(i), field7.PointerSparseSharedManaged(i), field8.PointerSparseSharedManaged(i), field9.PointerSparseSharedManaged(i), field10.PointerSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 
     /// <summary>
@@ -296,25 +1288,135 @@ public static Entity Find<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(Iter it,
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8); byte* pointer9 = (byte*)it.GetPointer<T9>(9); byte* pointer10 = (byte*)it.GetPointer<T10>(10);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8); int step9 = it.Step<T9>(9); int step10 = it.Step<T10>(10);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8); FieldData<T9> field9 = it.GetFieldData<T9>(9); FieldData<T10> field10 = it.GetFieldData<T10>(10);
+        IterationTechnique flags = it.GetIterationTechnique(11);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8], pointer9 = &pointer9[step9], pointer10 = &pointer10[step10])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>() || RuntimeHelpers.IsReferenceOrContainsReferences<T9>() || RuntimeHelpers.IsReferenceOrContainsReferences<T10>())
         {
-            if (!callback((T0*)pointer0, (T1*)pointer1, (T2*)pointer2, (T3*)pointer3, (T4*)pointer4, (T5*)pointer5, (T6*)pointer6, (T7*)pointer7, (T8*)pointer8, (T9*)pointer9, (T10*)pointer10))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerUnmanaged(i), field1.PointerUnmanaged(i), field2.PointerUnmanaged(i), field3.PointerUnmanaged(i), field4.PointerUnmanaged(i), field5.PointerUnmanaged(i), field6.PointerUnmanaged(i), field7.PointerUnmanaged(i), field8.PointerUnmanaged(i), field9.PointerUnmanaged(i), field10.PointerUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSharedUnmanaged(i), field1.PointerSharedUnmanaged(i), field2.PointerSharedUnmanaged(i), field3.PointerSharedUnmanaged(i), field4.PointerSharedUnmanaged(i), field5.PointerSharedUnmanaged(i), field6.PointerSharedUnmanaged(i), field7.PointerSharedUnmanaged(i), field8.PointerSharedUnmanaged(i), field9.PointerSharedUnmanaged(i), field10.PointerSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSparseUnmanaged(i), field1.PointerSparseUnmanaged(i), field2.PointerSparseUnmanaged(i), field3.PointerSparseUnmanaged(i), field4.PointerSparseUnmanaged(i), field5.PointerSparseUnmanaged(i), field6.PointerSparseUnmanaged(i), field7.PointerSparseUnmanaged(i), field8.PointerSparseUnmanaged(i), field9.PointerSparseUnmanaged(i), field10.PointerSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSparseSharedUnmanaged(i), field1.PointerSparseSharedUnmanaged(i), field2.PointerSparseSharedUnmanaged(i), field3.PointerSparseSharedUnmanaged(i), field4.PointerSparseSharedUnmanaged(i), field5.PointerSparseSharedUnmanaged(i), field6.PointerSparseSharedUnmanaged(i), field7.PointerSparseSharedUnmanaged(i), field8.PointerSparseSharedUnmanaged(i), field9.PointerSparseSharedUnmanaged(i), field10.PointerSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerManaged(i), field1.PointerManaged(i), field2.PointerManaged(i), field3.PointerManaged(i), field4.PointerManaged(i), field5.PointerManaged(i), field6.PointerManaged(i), field7.PointerManaged(i), field8.PointerManaged(i), field9.PointerManaged(i), field10.PointerManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSharedManaged(i), field1.PointerSharedManaged(i), field2.PointerSharedManaged(i), field3.PointerSharedManaged(i), field4.PointerSharedManaged(i), field5.PointerSharedManaged(i), field6.PointerSharedManaged(i), field7.PointerSharedManaged(i), field8.PointerSharedManaged(i), field9.PointerSharedManaged(i), field10.PointerSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSparseManaged(i), field1.PointerSparseManaged(i), field2.PointerSparseManaged(i), field3.PointerSparseManaged(i), field4.PointerSparseManaged(i), field5.PointerSparseManaged(i), field6.PointerSparseManaged(i), field7.PointerSparseManaged(i), field8.PointerSparseManaged(i), field9.PointerSparseManaged(i), field10.PointerSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSparseSharedManaged(i), field1.PointerSparseSharedManaged(i), field2.PointerSparseSharedManaged(i), field3.PointerSparseSharedManaged(i), field4.PointerSparseSharedManaged(i), field5.PointerSparseSharedManaged(i), field6.PointerSparseSharedManaged(i), field7.PointerSparseSharedManaged(i), field8.PointerSparseSharedManaged(i), field9.PointerSparseSharedManaged(i), field10.PointerSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 
     /// <summary>
@@ -327,25 +1429,135 @@ public static Entity Find<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(Iter it,
     {
         int count = it.Handle->count; Ecs.Assert(it.Handle->count > 0, "No entities returned, use Iter() or Each() without the entity argument instead.");
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8); byte* pointer9 = (byte*)it.GetPointer<T9>(9); byte* pointer10 = (byte*)it.GetPointer<T10>(10);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8); int step9 = it.Step<T9>(9); int step10 = it.Step<T10>(10);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8); FieldData<T9> field9 = it.GetFieldData<T9>(9); FieldData<T10> field10 = it.GetFieldData<T10>(10);
+        IterationTechnique flags = it.GetIterationTechnique(11);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8], pointer9 = &pointer9[step9], pointer10 = &pointer10[step10])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>() || RuntimeHelpers.IsReferenceOrContainsReferences<T9>() || RuntimeHelpers.IsReferenceOrContainsReferences<T10>())
         {
-            if (!callback(new Entity(it.Handle->world, it.Handle->entities[i]), (T0*)pointer0, (T1*)pointer1, (T2*)pointer2, (T3*)pointer3, (T4*)pointer4, (T5*)pointer5, (T6*)pointer6, (T7*)pointer7, (T8*)pointer8, (T9*)pointer9, (T10*)pointer10))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerUnmanaged(i), field1.PointerUnmanaged(i), field2.PointerUnmanaged(i), field3.PointerUnmanaged(i), field4.PointerUnmanaged(i), field5.PointerUnmanaged(i), field6.PointerUnmanaged(i), field7.PointerUnmanaged(i), field8.PointerUnmanaged(i), field9.PointerUnmanaged(i), field10.PointerUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSharedUnmanaged(i), field1.PointerSharedUnmanaged(i), field2.PointerSharedUnmanaged(i), field3.PointerSharedUnmanaged(i), field4.PointerSharedUnmanaged(i), field5.PointerSharedUnmanaged(i), field6.PointerSharedUnmanaged(i), field7.PointerSharedUnmanaged(i), field8.PointerSharedUnmanaged(i), field9.PointerSharedUnmanaged(i), field10.PointerSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseUnmanaged(i), field1.PointerSparseUnmanaged(i), field2.PointerSparseUnmanaged(i), field3.PointerSparseUnmanaged(i), field4.PointerSparseUnmanaged(i), field5.PointerSparseUnmanaged(i), field6.PointerSparseUnmanaged(i), field7.PointerSparseUnmanaged(i), field8.PointerSparseUnmanaged(i), field9.PointerSparseUnmanaged(i), field10.PointerSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseSharedUnmanaged(i), field1.PointerSparseSharedUnmanaged(i), field2.PointerSparseSharedUnmanaged(i), field3.PointerSparseSharedUnmanaged(i), field4.PointerSparseSharedUnmanaged(i), field5.PointerSparseSharedUnmanaged(i), field6.PointerSparseSharedUnmanaged(i), field7.PointerSparseSharedUnmanaged(i), field8.PointerSparseSharedUnmanaged(i), field9.PointerSparseSharedUnmanaged(i), field10.PointerSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerManaged(i), field1.PointerManaged(i), field2.PointerManaged(i), field3.PointerManaged(i), field4.PointerManaged(i), field5.PointerManaged(i), field6.PointerManaged(i), field7.PointerManaged(i), field8.PointerManaged(i), field9.PointerManaged(i), field10.PointerManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSharedManaged(i), field1.PointerSharedManaged(i), field2.PointerSharedManaged(i), field3.PointerSharedManaged(i), field4.PointerSharedManaged(i), field5.PointerSharedManaged(i), field6.PointerSharedManaged(i), field7.PointerSharedManaged(i), field8.PointerSharedManaged(i), field9.PointerSharedManaged(i), field10.PointerSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseManaged(i), field1.PointerSparseManaged(i), field2.PointerSparseManaged(i), field3.PointerSparseManaged(i), field4.PointerSparseManaged(i), field5.PointerSparseManaged(i), field6.PointerSparseManaged(i), field7.PointerSparseManaged(i), field8.PointerSparseManaged(i), field9.PointerSparseManaged(i), field10.PointerSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseSharedManaged(i), field1.PointerSparseSharedManaged(i), field2.PointerSparseSharedManaged(i), field3.PointerSparseSharedManaged(i), field4.PointerSparseSharedManaged(i), field5.PointerSparseSharedManaged(i), field6.PointerSparseSharedManaged(i), field7.PointerSparseSharedManaged(i), field8.PointerSparseSharedManaged(i), field9.PointerSparseSharedManaged(i), field10.PointerSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 
     /// <summary>
@@ -358,24 +1570,134 @@ public static Entity Find<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(Iter it,
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8); byte* pointer9 = (byte*)it.GetPointer<T9>(9); byte* pointer10 = (byte*)it.GetPointer<T10>(10);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8); int step9 = it.Step<T9>(9); int step10 = it.Step<T10>(10);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8); FieldData<T9> field9 = it.GetFieldData<T9>(9); FieldData<T10> field10 = it.GetFieldData<T10>(10);
+        IterationTechnique flags = it.GetIterationTechnique(11);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8], pointer9 = &pointer9[step9], pointer10 = &pointer10[step10])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>() || RuntimeHelpers.IsReferenceOrContainsReferences<T9>() || RuntimeHelpers.IsReferenceOrContainsReferences<T10>())
         {
-            if (!callback(it, i, (T0*)pointer0, (T1*)pointer1, (T2*)pointer2, (T3*)pointer3, (T4*)pointer4, (T5*)pointer5, (T6*)pointer6, (T7*)pointer7, (T8*)pointer8, (T9*)pointer9, (T10*)pointer10))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerUnmanaged(i), field1.PointerUnmanaged(i), field2.PointerUnmanaged(i), field3.PointerUnmanaged(i), field4.PointerUnmanaged(i), field5.PointerUnmanaged(i), field6.PointerUnmanaged(i), field7.PointerUnmanaged(i), field8.PointerUnmanaged(i), field9.PointerUnmanaged(i), field10.PointerUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSharedUnmanaged(i), field1.PointerSharedUnmanaged(i), field2.PointerSharedUnmanaged(i), field3.PointerSharedUnmanaged(i), field4.PointerSharedUnmanaged(i), field5.PointerSharedUnmanaged(i), field6.PointerSharedUnmanaged(i), field7.PointerSharedUnmanaged(i), field8.PointerSharedUnmanaged(i), field9.PointerSharedUnmanaged(i), field10.PointerSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSparseUnmanaged(i), field1.PointerSparseUnmanaged(i), field2.PointerSparseUnmanaged(i), field3.PointerSparseUnmanaged(i), field4.PointerSparseUnmanaged(i), field5.PointerSparseUnmanaged(i), field6.PointerSparseUnmanaged(i), field7.PointerSparseUnmanaged(i), field8.PointerSparseUnmanaged(i), field9.PointerSparseUnmanaged(i), field10.PointerSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSparseSharedUnmanaged(i), field1.PointerSparseSharedUnmanaged(i), field2.PointerSparseSharedUnmanaged(i), field3.PointerSparseSharedUnmanaged(i), field4.PointerSparseSharedUnmanaged(i), field5.PointerSparseSharedUnmanaged(i), field6.PointerSparseSharedUnmanaged(i), field7.PointerSparseSharedUnmanaged(i), field8.PointerSparseSharedUnmanaged(i), field9.PointerSparseSharedUnmanaged(i), field10.PointerSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerManaged(i), field1.PointerManaged(i), field2.PointerManaged(i), field3.PointerManaged(i), field4.PointerManaged(i), field5.PointerManaged(i), field6.PointerManaged(i), field7.PointerManaged(i), field8.PointerManaged(i), field9.PointerManaged(i), field10.PointerManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSharedManaged(i), field1.PointerSharedManaged(i), field2.PointerSharedManaged(i), field3.PointerSharedManaged(i), field4.PointerSharedManaged(i), field5.PointerSharedManaged(i), field6.PointerSharedManaged(i), field7.PointerSharedManaged(i), field8.PointerSharedManaged(i), field9.PointerSharedManaged(i), field10.PointerSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSparseManaged(i), field1.PointerSparseManaged(i), field2.PointerSparseManaged(i), field3.PointerSparseManaged(i), field4.PointerSparseManaged(i), field5.PointerSparseManaged(i), field6.PointerSparseManaged(i), field7.PointerSparseManaged(i), field8.PointerSparseManaged(i), field9.PointerSparseManaged(i), field10.PointerSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSparseSharedManaged(i), field1.PointerSparseSharedManaged(i), field2.PointerSparseSharedManaged(i), field3.PointerSparseSharedManaged(i), field4.PointerSparseSharedManaged(i), field5.PointerSparseSharedManaged(i), field6.PointerSparseSharedManaged(i), field7.PointerSparseSharedManaged(i), field8.PointerSparseSharedManaged(i), field9.PointerSparseSharedManaged(i), field10.PointerSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 }
\ No newline at end of file
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/Invoker/Find/Iterator/T12.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/Invoker/Find/Iterator/T12.g.cs
index 4bc15f05..d9fa81a8 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/Invoker/Find/Iterator/T12.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/Invoker/Find/Iterator/T12.g.cs
@@ -1,5 +1,7 @@
 // Find/Iterator/T12.g.cs
 // File was auto-generated by /_/src/Flecs.NET.Codegen/Generators/Invoker.cs
+using System;
+using System.Runtime.CompilerServices;
 using Flecs.NET.Utilities;
 using static Flecs.NET.Bindings.flecs;
 
@@ -17,25 +19,135 @@ public static Entity Find<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(Iter
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8); byte* pointer9 = (byte*)it.GetPointer<T9>(9); byte* pointer10 = (byte*)it.GetPointer<T10>(10); byte* pointer11 = (byte*)it.GetPointer<T11>(11);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8); int step9 = it.Step<T9>(9); int step10 = it.Step<T10>(10); int step11 = it.Step<T11>(11);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8); FieldData<T9> field9 = it.GetFieldData<T9>(9); FieldData<T10> field10 = it.GetFieldData<T10>(10); FieldData<T11> field11 = it.GetFieldData<T11>(11);
+        IterationTechnique flags = it.GetIterationTechnique(12);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8], pointer9 = &pointer9[step9], pointer10 = &pointer10[step10], pointer11 = &pointer11[step11])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>() || RuntimeHelpers.IsReferenceOrContainsReferences<T9>() || RuntimeHelpers.IsReferenceOrContainsReferences<T10>() || RuntimeHelpers.IsReferenceOrContainsReferences<T11>())
         {
-            if (!callback(ref Managed.GetTypeRef<T0>(pointer0), ref Managed.GetTypeRef<T1>(pointer1), ref Managed.GetTypeRef<T2>(pointer2), ref Managed.GetTypeRef<T3>(pointer3), ref Managed.GetTypeRef<T4>(pointer4), ref Managed.GetTypeRef<T5>(pointer5), ref Managed.GetTypeRef<T6>(pointer6), ref Managed.GetTypeRef<T7>(pointer7), ref Managed.GetTypeRef<T8>(pointer8), ref Managed.GetTypeRef<T9>(pointer9), ref Managed.GetTypeRef<T10>(pointer10), ref Managed.GetTypeRef<T11>(pointer11)))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, Ecs.FindRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefUnmanaged(i), ref field1.RefUnmanaged(i), ref field2.RefUnmanaged(i), ref field3.RefUnmanaged(i), ref field4.RefUnmanaged(i), ref field5.RefUnmanaged(i), ref field6.RefUnmanaged(i), ref field7.RefUnmanaged(i), ref field8.RefUnmanaged(i), ref field9.RefUnmanaged(i), ref field10.RefUnmanaged(i), ref field11.RefUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, Ecs.FindRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSharedUnmanaged(i), ref field1.RefSharedUnmanaged(i), ref field2.RefSharedUnmanaged(i), ref field3.RefSharedUnmanaged(i), ref field4.RefSharedUnmanaged(i), ref field5.RefSharedUnmanaged(i), ref field6.RefSharedUnmanaged(i), ref field7.RefSharedUnmanaged(i), ref field8.RefSharedUnmanaged(i), ref field9.RefSharedUnmanaged(i), ref field10.RefSharedUnmanaged(i), ref field11.RefSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, Ecs.FindRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSparseUnmanaged(i), ref field1.RefSparseUnmanaged(i), ref field2.RefSparseUnmanaged(i), ref field3.RefSparseUnmanaged(i), ref field4.RefSparseUnmanaged(i), ref field5.RefSparseUnmanaged(i), ref field6.RefSparseUnmanaged(i), ref field7.RefSparseUnmanaged(i), ref field8.RefSparseUnmanaged(i), ref field9.RefSparseUnmanaged(i), ref field10.RefSparseUnmanaged(i), ref field11.RefSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, Ecs.FindRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSparseSharedUnmanaged(i), ref field1.RefSparseSharedUnmanaged(i), ref field2.RefSparseSharedUnmanaged(i), ref field3.RefSparseSharedUnmanaged(i), ref field4.RefSparseSharedUnmanaged(i), ref field5.RefSparseSharedUnmanaged(i), ref field6.RefSparseSharedUnmanaged(i), ref field7.RefSparseSharedUnmanaged(i), ref field8.RefSparseSharedUnmanaged(i), ref field9.RefSparseSharedUnmanaged(i), ref field10.RefSparseSharedUnmanaged(i), ref field11.RefSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, Ecs.FindRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefManaged(i), ref field1.RefManaged(i), ref field2.RefManaged(i), ref field3.RefManaged(i), ref field4.RefManaged(i), ref field5.RefManaged(i), ref field6.RefManaged(i), ref field7.RefManaged(i), ref field8.RefManaged(i), ref field9.RefManaged(i), ref field10.RefManaged(i), ref field11.RefManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, Ecs.FindRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSharedManaged(i), ref field1.RefSharedManaged(i), ref field2.RefSharedManaged(i), ref field3.RefSharedManaged(i), ref field4.RefSharedManaged(i), ref field5.RefSharedManaged(i), ref field6.RefSharedManaged(i), ref field7.RefSharedManaged(i), ref field8.RefSharedManaged(i), ref field9.RefSharedManaged(i), ref field10.RefSharedManaged(i), ref field11.RefSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, Ecs.FindRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSparseManaged(i), ref field1.RefSparseManaged(i), ref field2.RefSparseManaged(i), ref field3.RefSparseManaged(i), ref field4.RefSparseManaged(i), ref field5.RefSparseManaged(i), ref field6.RefSparseManaged(i), ref field7.RefSparseManaged(i), ref field8.RefSparseManaged(i), ref field9.RefSparseManaged(i), ref field10.RefSparseManaged(i), ref field11.RefSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, Ecs.FindRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSparseSharedManaged(i), ref field1.RefSparseSharedManaged(i), ref field2.RefSparseSharedManaged(i), ref field3.RefSparseSharedManaged(i), ref field4.RefSparseSharedManaged(i), ref field5.RefSparseSharedManaged(i), ref field6.RefSparseSharedManaged(i), ref field7.RefSparseSharedManaged(i), ref field8.RefSparseSharedManaged(i), ref field9.RefSparseSharedManaged(i), ref field10.RefSparseSharedManaged(i), ref field11.RefSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 
     /// <summary>
@@ -48,25 +160,135 @@ public static Entity Find<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(Iter
     {
         int count = it.Handle->count; Ecs.Assert(it.Handle->count > 0, "No entities returned, use Iter() or Each() without the entity argument instead.");
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8); byte* pointer9 = (byte*)it.GetPointer<T9>(9); byte* pointer10 = (byte*)it.GetPointer<T10>(10); byte* pointer11 = (byte*)it.GetPointer<T11>(11);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8); int step9 = it.Step<T9>(9); int step10 = it.Step<T10>(10); int step11 = it.Step<T11>(11);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8); FieldData<T9> field9 = it.GetFieldData<T9>(9); FieldData<T10> field10 = it.GetFieldData<T10>(10); FieldData<T11> field11 = it.GetFieldData<T11>(11);
+        IterationTechnique flags = it.GetIterationTechnique(12);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8], pointer9 = &pointer9[step9], pointer10 = &pointer10[step10], pointer11 = &pointer11[step11])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>() || RuntimeHelpers.IsReferenceOrContainsReferences<T9>() || RuntimeHelpers.IsReferenceOrContainsReferences<T10>() || RuntimeHelpers.IsReferenceOrContainsReferences<T11>())
         {
-            if (!callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref Managed.GetTypeRef<T0>(pointer0), ref Managed.GetTypeRef<T1>(pointer1), ref Managed.GetTypeRef<T2>(pointer2), ref Managed.GetTypeRef<T3>(pointer3), ref Managed.GetTypeRef<T4>(pointer4), ref Managed.GetTypeRef<T5>(pointer5), ref Managed.GetTypeRef<T6>(pointer6), ref Managed.GetTypeRef<T7>(pointer7), ref Managed.GetTypeRef<T8>(pointer8), ref Managed.GetTypeRef<T9>(pointer9), ref Managed.GetTypeRef<T10>(pointer10), ref Managed.GetTypeRef<T11>(pointer11)))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefUnmanaged(i), ref field1.RefUnmanaged(i), ref field2.RefUnmanaged(i), ref field3.RefUnmanaged(i), ref field4.RefUnmanaged(i), ref field5.RefUnmanaged(i), ref field6.RefUnmanaged(i), ref field7.RefUnmanaged(i), ref field8.RefUnmanaged(i), ref field9.RefUnmanaged(i), ref field10.RefUnmanaged(i), ref field11.RefUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSharedUnmanaged(i), ref field1.RefSharedUnmanaged(i), ref field2.RefSharedUnmanaged(i), ref field3.RefSharedUnmanaged(i), ref field4.RefSharedUnmanaged(i), ref field5.RefSharedUnmanaged(i), ref field6.RefSharedUnmanaged(i), ref field7.RefSharedUnmanaged(i), ref field8.RefSharedUnmanaged(i), ref field9.RefSharedUnmanaged(i), ref field10.RefSharedUnmanaged(i), ref field11.RefSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseUnmanaged(i), ref field1.RefSparseUnmanaged(i), ref field2.RefSparseUnmanaged(i), ref field3.RefSparseUnmanaged(i), ref field4.RefSparseUnmanaged(i), ref field5.RefSparseUnmanaged(i), ref field6.RefSparseUnmanaged(i), ref field7.RefSparseUnmanaged(i), ref field8.RefSparseUnmanaged(i), ref field9.RefSparseUnmanaged(i), ref field10.RefSparseUnmanaged(i), ref field11.RefSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseSharedUnmanaged(i), ref field1.RefSparseSharedUnmanaged(i), ref field2.RefSparseSharedUnmanaged(i), ref field3.RefSparseSharedUnmanaged(i), ref field4.RefSparseSharedUnmanaged(i), ref field5.RefSparseSharedUnmanaged(i), ref field6.RefSparseSharedUnmanaged(i), ref field7.RefSparseSharedUnmanaged(i), ref field8.RefSparseSharedUnmanaged(i), ref field9.RefSparseSharedUnmanaged(i), ref field10.RefSparseSharedUnmanaged(i), ref field11.RefSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefManaged(i), ref field1.RefManaged(i), ref field2.RefManaged(i), ref field3.RefManaged(i), ref field4.RefManaged(i), ref field5.RefManaged(i), ref field6.RefManaged(i), ref field7.RefManaged(i), ref field8.RefManaged(i), ref field9.RefManaged(i), ref field10.RefManaged(i), ref field11.RefManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSharedManaged(i), ref field1.RefSharedManaged(i), ref field2.RefSharedManaged(i), ref field3.RefSharedManaged(i), ref field4.RefSharedManaged(i), ref field5.RefSharedManaged(i), ref field6.RefSharedManaged(i), ref field7.RefSharedManaged(i), ref field8.RefSharedManaged(i), ref field9.RefSharedManaged(i), ref field10.RefSharedManaged(i), ref field11.RefSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseManaged(i), ref field1.RefSparseManaged(i), ref field2.RefSparseManaged(i), ref field3.RefSparseManaged(i), ref field4.RefSparseManaged(i), ref field5.RefSparseManaged(i), ref field6.RefSparseManaged(i), ref field7.RefSparseManaged(i), ref field8.RefSparseManaged(i), ref field9.RefSparseManaged(i), ref field10.RefSparseManaged(i), ref field11.RefSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseSharedManaged(i), ref field1.RefSparseSharedManaged(i), ref field2.RefSparseSharedManaged(i), ref field3.RefSparseSharedManaged(i), ref field4.RefSparseSharedManaged(i), ref field5.RefSparseSharedManaged(i), ref field6.RefSparseSharedManaged(i), ref field7.RefSparseSharedManaged(i), ref field8.RefSparseSharedManaged(i), ref field9.RefSparseSharedManaged(i), ref field10.RefSparseSharedManaged(i), ref field11.RefSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 
     /// <summary>
@@ -79,25 +301,135 @@ public static Entity Find<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(Iter
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8); byte* pointer9 = (byte*)it.GetPointer<T9>(9); byte* pointer10 = (byte*)it.GetPointer<T10>(10); byte* pointer11 = (byte*)it.GetPointer<T11>(11);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8); int step9 = it.Step<T9>(9); int step10 = it.Step<T10>(10); int step11 = it.Step<T11>(11);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8); FieldData<T9> field9 = it.GetFieldData<T9>(9); FieldData<T10> field10 = it.GetFieldData<T10>(10); FieldData<T11> field11 = it.GetFieldData<T11>(11);
+        IterationTechnique flags = it.GetIterationTechnique(12);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8], pointer9 = &pointer9[step9], pointer10 = &pointer10[step10], pointer11 = &pointer11[step11])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>() || RuntimeHelpers.IsReferenceOrContainsReferences<T9>() || RuntimeHelpers.IsReferenceOrContainsReferences<T10>() || RuntimeHelpers.IsReferenceOrContainsReferences<T11>())
         {
-            if (!callback(it, i, ref Managed.GetTypeRef<T0>(pointer0), ref Managed.GetTypeRef<T1>(pointer1), ref Managed.GetTypeRef<T2>(pointer2), ref Managed.GetTypeRef<T3>(pointer3), ref Managed.GetTypeRef<T4>(pointer4), ref Managed.GetTypeRef<T5>(pointer5), ref Managed.GetTypeRef<T6>(pointer6), ref Managed.GetTypeRef<T7>(pointer7), ref Managed.GetTypeRef<T8>(pointer8), ref Managed.GetTypeRef<T9>(pointer9), ref Managed.GetTypeRef<T10>(pointer10), ref Managed.GetTypeRef<T11>(pointer11)))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, Ecs.FindIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefUnmanaged(i), ref field1.RefUnmanaged(i), ref field2.RefUnmanaged(i), ref field3.RefUnmanaged(i), ref field4.RefUnmanaged(i), ref field5.RefUnmanaged(i), ref field6.RefUnmanaged(i), ref field7.RefUnmanaged(i), ref field8.RefUnmanaged(i), ref field9.RefUnmanaged(i), ref field10.RefUnmanaged(i), ref field11.RefUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, Ecs.FindIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSharedUnmanaged(i), ref field1.RefSharedUnmanaged(i), ref field2.RefSharedUnmanaged(i), ref field3.RefSharedUnmanaged(i), ref field4.RefSharedUnmanaged(i), ref field5.RefSharedUnmanaged(i), ref field6.RefSharedUnmanaged(i), ref field7.RefSharedUnmanaged(i), ref field8.RefSharedUnmanaged(i), ref field9.RefSharedUnmanaged(i), ref field10.RefSharedUnmanaged(i), ref field11.RefSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, Ecs.FindIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSparseUnmanaged(i), ref field1.RefSparseUnmanaged(i), ref field2.RefSparseUnmanaged(i), ref field3.RefSparseUnmanaged(i), ref field4.RefSparseUnmanaged(i), ref field5.RefSparseUnmanaged(i), ref field6.RefSparseUnmanaged(i), ref field7.RefSparseUnmanaged(i), ref field8.RefSparseUnmanaged(i), ref field9.RefSparseUnmanaged(i), ref field10.RefSparseUnmanaged(i), ref field11.RefSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, Ecs.FindIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSparseSharedUnmanaged(i), ref field1.RefSparseSharedUnmanaged(i), ref field2.RefSparseSharedUnmanaged(i), ref field3.RefSparseSharedUnmanaged(i), ref field4.RefSparseSharedUnmanaged(i), ref field5.RefSparseSharedUnmanaged(i), ref field6.RefSparseSharedUnmanaged(i), ref field7.RefSparseSharedUnmanaged(i), ref field8.RefSparseSharedUnmanaged(i), ref field9.RefSparseSharedUnmanaged(i), ref field10.RefSparseSharedUnmanaged(i), ref field11.RefSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, Ecs.FindIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefManaged(i), ref field1.RefManaged(i), ref field2.RefManaged(i), ref field3.RefManaged(i), ref field4.RefManaged(i), ref field5.RefManaged(i), ref field6.RefManaged(i), ref field7.RefManaged(i), ref field8.RefManaged(i), ref field9.RefManaged(i), ref field10.RefManaged(i), ref field11.RefManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, Ecs.FindIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSharedManaged(i), ref field1.RefSharedManaged(i), ref field2.RefSharedManaged(i), ref field3.RefSharedManaged(i), ref field4.RefSharedManaged(i), ref field5.RefSharedManaged(i), ref field6.RefSharedManaged(i), ref field7.RefSharedManaged(i), ref field8.RefSharedManaged(i), ref field9.RefSharedManaged(i), ref field10.RefSharedManaged(i), ref field11.RefSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, Ecs.FindIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSparseManaged(i), ref field1.RefSparseManaged(i), ref field2.RefSparseManaged(i), ref field3.RefSparseManaged(i), ref field4.RefSparseManaged(i), ref field5.RefSparseManaged(i), ref field6.RefSparseManaged(i), ref field7.RefSparseManaged(i), ref field8.RefSparseManaged(i), ref field9.RefSparseManaged(i), ref field10.RefSparseManaged(i), ref field11.RefSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, Ecs.FindIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSparseSharedManaged(i), ref field1.RefSparseSharedManaged(i), ref field2.RefSparseSharedManaged(i), ref field3.RefSparseSharedManaged(i), ref field4.RefSparseSharedManaged(i), ref field5.RefSparseSharedManaged(i), ref field6.RefSparseSharedManaged(i), ref field7.RefSparseSharedManaged(i), ref field8.RefSparseSharedManaged(i), ref field9.RefSparseSharedManaged(i), ref field10.RefSparseSharedManaged(i), ref field11.RefSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 
     /// <summary>
@@ -110,25 +442,135 @@ public static Entity Find<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(Iter
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8); byte* pointer9 = (byte*)it.GetPointer<T9>(9); byte* pointer10 = (byte*)it.GetPointer<T10>(10); byte* pointer11 = (byte*)it.GetPointer<T11>(11);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8); int step9 = it.Step<T9>(9); int step10 = it.Step<T10>(10); int step11 = it.Step<T11>(11);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8); FieldData<T9> field9 = it.GetFieldData<T9>(9); FieldData<T10> field10 = it.GetFieldData<T10>(10); FieldData<T11> field11 = it.GetFieldData<T11>(11);
+        IterationTechnique flags = it.GetIterationTechnique(12);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8], pointer9 = &pointer9[step9], pointer10 = &pointer10[step10], pointer11 = &pointer11[step11])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>() || RuntimeHelpers.IsReferenceOrContainsReferences<T9>() || RuntimeHelpers.IsReferenceOrContainsReferences<T10>() || RuntimeHelpers.IsReferenceOrContainsReferences<T11>())
         {
-            if (!callback(ref Managed.GetTypeRef<T0>(pointer0), ref Managed.GetTypeRef<T1>(pointer1), ref Managed.GetTypeRef<T2>(pointer2), ref Managed.GetTypeRef<T3>(pointer3), ref Managed.GetTypeRef<T4>(pointer4), ref Managed.GetTypeRef<T5>(pointer5), ref Managed.GetTypeRef<T6>(pointer6), ref Managed.GetTypeRef<T7>(pointer7), ref Managed.GetTypeRef<T8>(pointer8), ref Managed.GetTypeRef<T9>(pointer9), ref Managed.GetTypeRef<T10>(pointer10), ref Managed.GetTypeRef<T11>(pointer11)))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefUnmanaged(i), ref field1.RefUnmanaged(i), ref field2.RefUnmanaged(i), ref field3.RefUnmanaged(i), ref field4.RefUnmanaged(i), ref field5.RefUnmanaged(i), ref field6.RefUnmanaged(i), ref field7.RefUnmanaged(i), ref field8.RefUnmanaged(i), ref field9.RefUnmanaged(i), ref field10.RefUnmanaged(i), ref field11.RefUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSharedUnmanaged(i), ref field1.RefSharedUnmanaged(i), ref field2.RefSharedUnmanaged(i), ref field3.RefSharedUnmanaged(i), ref field4.RefSharedUnmanaged(i), ref field5.RefSharedUnmanaged(i), ref field6.RefSharedUnmanaged(i), ref field7.RefSharedUnmanaged(i), ref field8.RefSharedUnmanaged(i), ref field9.RefSharedUnmanaged(i), ref field10.RefSharedUnmanaged(i), ref field11.RefSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSparseUnmanaged(i), ref field1.RefSparseUnmanaged(i), ref field2.RefSparseUnmanaged(i), ref field3.RefSparseUnmanaged(i), ref field4.RefSparseUnmanaged(i), ref field5.RefSparseUnmanaged(i), ref field6.RefSparseUnmanaged(i), ref field7.RefSparseUnmanaged(i), ref field8.RefSparseUnmanaged(i), ref field9.RefSparseUnmanaged(i), ref field10.RefSparseUnmanaged(i), ref field11.RefSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSparseSharedUnmanaged(i), ref field1.RefSparseSharedUnmanaged(i), ref field2.RefSparseSharedUnmanaged(i), ref field3.RefSparseSharedUnmanaged(i), ref field4.RefSparseSharedUnmanaged(i), ref field5.RefSparseSharedUnmanaged(i), ref field6.RefSparseSharedUnmanaged(i), ref field7.RefSparseSharedUnmanaged(i), ref field8.RefSparseSharedUnmanaged(i), ref field9.RefSparseSharedUnmanaged(i), ref field10.RefSparseSharedUnmanaged(i), ref field11.RefSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefManaged(i), ref field1.RefManaged(i), ref field2.RefManaged(i), ref field3.RefManaged(i), ref field4.RefManaged(i), ref field5.RefManaged(i), ref field6.RefManaged(i), ref field7.RefManaged(i), ref field8.RefManaged(i), ref field9.RefManaged(i), ref field10.RefManaged(i), ref field11.RefManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSharedManaged(i), ref field1.RefSharedManaged(i), ref field2.RefSharedManaged(i), ref field3.RefSharedManaged(i), ref field4.RefSharedManaged(i), ref field5.RefSharedManaged(i), ref field6.RefSharedManaged(i), ref field7.RefSharedManaged(i), ref field8.RefSharedManaged(i), ref field9.RefSharedManaged(i), ref field10.RefSharedManaged(i), ref field11.RefSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSparseManaged(i), ref field1.RefSparseManaged(i), ref field2.RefSparseManaged(i), ref field3.RefSparseManaged(i), ref field4.RefSparseManaged(i), ref field5.RefSparseManaged(i), ref field6.RefSparseManaged(i), ref field7.RefSparseManaged(i), ref field8.RefSparseManaged(i), ref field9.RefSparseManaged(i), ref field10.RefSparseManaged(i), ref field11.RefSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSparseSharedManaged(i), ref field1.RefSparseSharedManaged(i), ref field2.RefSparseSharedManaged(i), ref field3.RefSparseSharedManaged(i), ref field4.RefSparseSharedManaged(i), ref field5.RefSparseSharedManaged(i), ref field6.RefSparseSharedManaged(i), ref field7.RefSparseSharedManaged(i), ref field8.RefSparseSharedManaged(i), ref field9.RefSparseSharedManaged(i), ref field10.RefSparseSharedManaged(i), ref field11.RefSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 
     /// <summary>
@@ -141,25 +583,135 @@ public static Entity Find<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(Iter
     {
         int count = it.Handle->count; Ecs.Assert(it.Handle->count > 0, "No entities returned, use Iter() or Each() without the entity argument instead.");
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8); byte* pointer9 = (byte*)it.GetPointer<T9>(9); byte* pointer10 = (byte*)it.GetPointer<T10>(10); byte* pointer11 = (byte*)it.GetPointer<T11>(11);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8); int step9 = it.Step<T9>(9); int step10 = it.Step<T10>(10); int step11 = it.Step<T11>(11);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8); FieldData<T9> field9 = it.GetFieldData<T9>(9); FieldData<T10> field10 = it.GetFieldData<T10>(10); FieldData<T11> field11 = it.GetFieldData<T11>(11);
+        IterationTechnique flags = it.GetIterationTechnique(12);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8], pointer9 = &pointer9[step9], pointer10 = &pointer10[step10], pointer11 = &pointer11[step11])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>() || RuntimeHelpers.IsReferenceOrContainsReferences<T9>() || RuntimeHelpers.IsReferenceOrContainsReferences<T10>() || RuntimeHelpers.IsReferenceOrContainsReferences<T11>())
         {
-            if (!callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref Managed.GetTypeRef<T0>(pointer0), ref Managed.GetTypeRef<T1>(pointer1), ref Managed.GetTypeRef<T2>(pointer2), ref Managed.GetTypeRef<T3>(pointer3), ref Managed.GetTypeRef<T4>(pointer4), ref Managed.GetTypeRef<T5>(pointer5), ref Managed.GetTypeRef<T6>(pointer6), ref Managed.GetTypeRef<T7>(pointer7), ref Managed.GetTypeRef<T8>(pointer8), ref Managed.GetTypeRef<T9>(pointer9), ref Managed.GetTypeRef<T10>(pointer10), ref Managed.GetTypeRef<T11>(pointer11)))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefUnmanaged(i), ref field1.RefUnmanaged(i), ref field2.RefUnmanaged(i), ref field3.RefUnmanaged(i), ref field4.RefUnmanaged(i), ref field5.RefUnmanaged(i), ref field6.RefUnmanaged(i), ref field7.RefUnmanaged(i), ref field8.RefUnmanaged(i), ref field9.RefUnmanaged(i), ref field10.RefUnmanaged(i), ref field11.RefUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSharedUnmanaged(i), ref field1.RefSharedUnmanaged(i), ref field2.RefSharedUnmanaged(i), ref field3.RefSharedUnmanaged(i), ref field4.RefSharedUnmanaged(i), ref field5.RefSharedUnmanaged(i), ref field6.RefSharedUnmanaged(i), ref field7.RefSharedUnmanaged(i), ref field8.RefSharedUnmanaged(i), ref field9.RefSharedUnmanaged(i), ref field10.RefSharedUnmanaged(i), ref field11.RefSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseUnmanaged(i), ref field1.RefSparseUnmanaged(i), ref field2.RefSparseUnmanaged(i), ref field3.RefSparseUnmanaged(i), ref field4.RefSparseUnmanaged(i), ref field5.RefSparseUnmanaged(i), ref field6.RefSparseUnmanaged(i), ref field7.RefSparseUnmanaged(i), ref field8.RefSparseUnmanaged(i), ref field9.RefSparseUnmanaged(i), ref field10.RefSparseUnmanaged(i), ref field11.RefSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseSharedUnmanaged(i), ref field1.RefSparseSharedUnmanaged(i), ref field2.RefSparseSharedUnmanaged(i), ref field3.RefSparseSharedUnmanaged(i), ref field4.RefSparseSharedUnmanaged(i), ref field5.RefSparseSharedUnmanaged(i), ref field6.RefSparseSharedUnmanaged(i), ref field7.RefSparseSharedUnmanaged(i), ref field8.RefSparseSharedUnmanaged(i), ref field9.RefSparseSharedUnmanaged(i), ref field10.RefSparseSharedUnmanaged(i), ref field11.RefSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefManaged(i), ref field1.RefManaged(i), ref field2.RefManaged(i), ref field3.RefManaged(i), ref field4.RefManaged(i), ref field5.RefManaged(i), ref field6.RefManaged(i), ref field7.RefManaged(i), ref field8.RefManaged(i), ref field9.RefManaged(i), ref field10.RefManaged(i), ref field11.RefManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSharedManaged(i), ref field1.RefSharedManaged(i), ref field2.RefSharedManaged(i), ref field3.RefSharedManaged(i), ref field4.RefSharedManaged(i), ref field5.RefSharedManaged(i), ref field6.RefSharedManaged(i), ref field7.RefSharedManaged(i), ref field8.RefSharedManaged(i), ref field9.RefSharedManaged(i), ref field10.RefSharedManaged(i), ref field11.RefSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseManaged(i), ref field1.RefSparseManaged(i), ref field2.RefSparseManaged(i), ref field3.RefSparseManaged(i), ref field4.RefSparseManaged(i), ref field5.RefSparseManaged(i), ref field6.RefSparseManaged(i), ref field7.RefSparseManaged(i), ref field8.RefSparseManaged(i), ref field9.RefSparseManaged(i), ref field10.RefSparseManaged(i), ref field11.RefSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseSharedManaged(i), ref field1.RefSparseSharedManaged(i), ref field2.RefSparseSharedManaged(i), ref field3.RefSparseSharedManaged(i), ref field4.RefSparseSharedManaged(i), ref field5.RefSparseSharedManaged(i), ref field6.RefSparseSharedManaged(i), ref field7.RefSparseSharedManaged(i), ref field8.RefSparseSharedManaged(i), ref field9.RefSparseSharedManaged(i), ref field10.RefSparseSharedManaged(i), ref field11.RefSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 
     /// <summary>
@@ -172,25 +724,135 @@ public static Entity Find<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(Iter
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8); byte* pointer9 = (byte*)it.GetPointer<T9>(9); byte* pointer10 = (byte*)it.GetPointer<T10>(10); byte* pointer11 = (byte*)it.GetPointer<T11>(11);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8); int step9 = it.Step<T9>(9); int step10 = it.Step<T10>(10); int step11 = it.Step<T11>(11);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8); FieldData<T9> field9 = it.GetFieldData<T9>(9); FieldData<T10> field10 = it.GetFieldData<T10>(10); FieldData<T11> field11 = it.GetFieldData<T11>(11);
+        IterationTechnique flags = it.GetIterationTechnique(12);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8], pointer9 = &pointer9[step9], pointer10 = &pointer10[step10], pointer11 = &pointer11[step11])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>() || RuntimeHelpers.IsReferenceOrContainsReferences<T9>() || RuntimeHelpers.IsReferenceOrContainsReferences<T10>() || RuntimeHelpers.IsReferenceOrContainsReferences<T11>())
         {
-            if (!callback(it, i, ref Managed.GetTypeRef<T0>(pointer0), ref Managed.GetTypeRef<T1>(pointer1), ref Managed.GetTypeRef<T2>(pointer2), ref Managed.GetTypeRef<T3>(pointer3), ref Managed.GetTypeRef<T4>(pointer4), ref Managed.GetTypeRef<T5>(pointer5), ref Managed.GetTypeRef<T6>(pointer6), ref Managed.GetTypeRef<T7>(pointer7), ref Managed.GetTypeRef<T8>(pointer8), ref Managed.GetTypeRef<T9>(pointer9), ref Managed.GetTypeRef<T10>(pointer10), ref Managed.GetTypeRef<T11>(pointer11)))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefUnmanaged(i), ref field1.RefUnmanaged(i), ref field2.RefUnmanaged(i), ref field3.RefUnmanaged(i), ref field4.RefUnmanaged(i), ref field5.RefUnmanaged(i), ref field6.RefUnmanaged(i), ref field7.RefUnmanaged(i), ref field8.RefUnmanaged(i), ref field9.RefUnmanaged(i), ref field10.RefUnmanaged(i), ref field11.RefUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSharedUnmanaged(i), ref field1.RefSharedUnmanaged(i), ref field2.RefSharedUnmanaged(i), ref field3.RefSharedUnmanaged(i), ref field4.RefSharedUnmanaged(i), ref field5.RefSharedUnmanaged(i), ref field6.RefSharedUnmanaged(i), ref field7.RefSharedUnmanaged(i), ref field8.RefSharedUnmanaged(i), ref field9.RefSharedUnmanaged(i), ref field10.RefSharedUnmanaged(i), ref field11.RefSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSparseUnmanaged(i), ref field1.RefSparseUnmanaged(i), ref field2.RefSparseUnmanaged(i), ref field3.RefSparseUnmanaged(i), ref field4.RefSparseUnmanaged(i), ref field5.RefSparseUnmanaged(i), ref field6.RefSparseUnmanaged(i), ref field7.RefSparseUnmanaged(i), ref field8.RefSparseUnmanaged(i), ref field9.RefSparseUnmanaged(i), ref field10.RefSparseUnmanaged(i), ref field11.RefSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSparseSharedUnmanaged(i), ref field1.RefSparseSharedUnmanaged(i), ref field2.RefSparseSharedUnmanaged(i), ref field3.RefSparseSharedUnmanaged(i), ref field4.RefSparseSharedUnmanaged(i), ref field5.RefSparseSharedUnmanaged(i), ref field6.RefSparseSharedUnmanaged(i), ref field7.RefSparseSharedUnmanaged(i), ref field8.RefSparseSharedUnmanaged(i), ref field9.RefSparseSharedUnmanaged(i), ref field10.RefSparseSharedUnmanaged(i), ref field11.RefSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefManaged(i), ref field1.RefManaged(i), ref field2.RefManaged(i), ref field3.RefManaged(i), ref field4.RefManaged(i), ref field5.RefManaged(i), ref field6.RefManaged(i), ref field7.RefManaged(i), ref field8.RefManaged(i), ref field9.RefManaged(i), ref field10.RefManaged(i), ref field11.RefManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSharedManaged(i), ref field1.RefSharedManaged(i), ref field2.RefSharedManaged(i), ref field3.RefSharedManaged(i), ref field4.RefSharedManaged(i), ref field5.RefSharedManaged(i), ref field6.RefSharedManaged(i), ref field7.RefSharedManaged(i), ref field8.RefSharedManaged(i), ref field9.RefSharedManaged(i), ref field10.RefSharedManaged(i), ref field11.RefSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSparseManaged(i), ref field1.RefSparseManaged(i), ref field2.RefSparseManaged(i), ref field3.RefSparseManaged(i), ref field4.RefSparseManaged(i), ref field5.RefSparseManaged(i), ref field6.RefSparseManaged(i), ref field7.RefSparseManaged(i), ref field8.RefSparseManaged(i), ref field9.RefSparseManaged(i), ref field10.RefSparseManaged(i), ref field11.RefSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSparseSharedManaged(i), ref field1.RefSparseSharedManaged(i), ref field2.RefSparseSharedManaged(i), ref field3.RefSparseSharedManaged(i), ref field4.RefSparseSharedManaged(i), ref field5.RefSparseSharedManaged(i), ref field6.RefSparseSharedManaged(i), ref field7.RefSparseSharedManaged(i), ref field8.RefSparseSharedManaged(i), ref field9.RefSparseSharedManaged(i), ref field10.RefSparseSharedManaged(i), ref field11.RefSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 
     /// <summary>
@@ -203,25 +865,135 @@ public static Entity Find<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(Iter
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8); byte* pointer9 = (byte*)it.GetPointer<T9>(9); byte* pointer10 = (byte*)it.GetPointer<T10>(10); byte* pointer11 = (byte*)it.GetPointer<T11>(11);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8); int step9 = it.Step<T9>(9); int step10 = it.Step<T10>(10); int step11 = it.Step<T11>(11);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8); FieldData<T9> field9 = it.GetFieldData<T9>(9); FieldData<T10> field10 = it.GetFieldData<T10>(10); FieldData<T11> field11 = it.GetFieldData<T11>(11);
+        IterationTechnique flags = it.GetIterationTechnique(12);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8], pointer9 = &pointer9[step9], pointer10 = &pointer10[step10], pointer11 = &pointer11[step11])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>() || RuntimeHelpers.IsReferenceOrContainsReferences<T9>() || RuntimeHelpers.IsReferenceOrContainsReferences<T10>() || RuntimeHelpers.IsReferenceOrContainsReferences<T11>())
         {
-            if (!callback((T0*)pointer0, (T1*)pointer1, (T2*)pointer2, (T3*)pointer3, (T4*)pointer4, (T5*)pointer5, (T6*)pointer6, (T7*)pointer7, (T8*)pointer8, (T9*)pointer9, (T10*)pointer10, (T11*)pointer11))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, Ecs.FindPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerUnmanaged(i), field1.PointerUnmanaged(i), field2.PointerUnmanaged(i), field3.PointerUnmanaged(i), field4.PointerUnmanaged(i), field5.PointerUnmanaged(i), field6.PointerUnmanaged(i), field7.PointerUnmanaged(i), field8.PointerUnmanaged(i), field9.PointerUnmanaged(i), field10.PointerUnmanaged(i), field11.PointerUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, Ecs.FindPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSharedUnmanaged(i), field1.PointerSharedUnmanaged(i), field2.PointerSharedUnmanaged(i), field3.PointerSharedUnmanaged(i), field4.PointerSharedUnmanaged(i), field5.PointerSharedUnmanaged(i), field6.PointerSharedUnmanaged(i), field7.PointerSharedUnmanaged(i), field8.PointerSharedUnmanaged(i), field9.PointerSharedUnmanaged(i), field10.PointerSharedUnmanaged(i), field11.PointerSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, Ecs.FindPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSparseUnmanaged(i), field1.PointerSparseUnmanaged(i), field2.PointerSparseUnmanaged(i), field3.PointerSparseUnmanaged(i), field4.PointerSparseUnmanaged(i), field5.PointerSparseUnmanaged(i), field6.PointerSparseUnmanaged(i), field7.PointerSparseUnmanaged(i), field8.PointerSparseUnmanaged(i), field9.PointerSparseUnmanaged(i), field10.PointerSparseUnmanaged(i), field11.PointerSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, Ecs.FindPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSparseSharedUnmanaged(i), field1.PointerSparseSharedUnmanaged(i), field2.PointerSparseSharedUnmanaged(i), field3.PointerSparseSharedUnmanaged(i), field4.PointerSparseSharedUnmanaged(i), field5.PointerSparseSharedUnmanaged(i), field6.PointerSparseSharedUnmanaged(i), field7.PointerSparseSharedUnmanaged(i), field8.PointerSparseSharedUnmanaged(i), field9.PointerSparseSharedUnmanaged(i), field10.PointerSparseSharedUnmanaged(i), field11.PointerSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, Ecs.FindPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerManaged(i), field1.PointerManaged(i), field2.PointerManaged(i), field3.PointerManaged(i), field4.PointerManaged(i), field5.PointerManaged(i), field6.PointerManaged(i), field7.PointerManaged(i), field8.PointerManaged(i), field9.PointerManaged(i), field10.PointerManaged(i), field11.PointerManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, Ecs.FindPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSharedManaged(i), field1.PointerSharedManaged(i), field2.PointerSharedManaged(i), field3.PointerSharedManaged(i), field4.PointerSharedManaged(i), field5.PointerSharedManaged(i), field6.PointerSharedManaged(i), field7.PointerSharedManaged(i), field8.PointerSharedManaged(i), field9.PointerSharedManaged(i), field10.PointerSharedManaged(i), field11.PointerSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, Ecs.FindPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSparseManaged(i), field1.PointerSparseManaged(i), field2.PointerSparseManaged(i), field3.PointerSparseManaged(i), field4.PointerSparseManaged(i), field5.PointerSparseManaged(i), field6.PointerSparseManaged(i), field7.PointerSparseManaged(i), field8.PointerSparseManaged(i), field9.PointerSparseManaged(i), field10.PointerSparseManaged(i), field11.PointerSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, Ecs.FindPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSparseSharedManaged(i), field1.PointerSparseSharedManaged(i), field2.PointerSparseSharedManaged(i), field3.PointerSparseSharedManaged(i), field4.PointerSparseSharedManaged(i), field5.PointerSparseSharedManaged(i), field6.PointerSparseSharedManaged(i), field7.PointerSparseSharedManaged(i), field8.PointerSparseSharedManaged(i), field9.PointerSparseSharedManaged(i), field10.PointerSparseSharedManaged(i), field11.PointerSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 
     /// <summary>
@@ -234,25 +1006,135 @@ public static Entity Find<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(Iter
     {
         int count = it.Handle->count; Ecs.Assert(it.Handle->count > 0, "No entities returned, use Iter() or Each() without the entity argument instead.");
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8); byte* pointer9 = (byte*)it.GetPointer<T9>(9); byte* pointer10 = (byte*)it.GetPointer<T10>(10); byte* pointer11 = (byte*)it.GetPointer<T11>(11);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8); int step9 = it.Step<T9>(9); int step10 = it.Step<T10>(10); int step11 = it.Step<T11>(11);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8); FieldData<T9> field9 = it.GetFieldData<T9>(9); FieldData<T10> field10 = it.GetFieldData<T10>(10); FieldData<T11> field11 = it.GetFieldData<T11>(11);
+        IterationTechnique flags = it.GetIterationTechnique(12);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8], pointer9 = &pointer9[step9], pointer10 = &pointer10[step10], pointer11 = &pointer11[step11])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>() || RuntimeHelpers.IsReferenceOrContainsReferences<T9>() || RuntimeHelpers.IsReferenceOrContainsReferences<T10>() || RuntimeHelpers.IsReferenceOrContainsReferences<T11>())
         {
-            if (!callback(new Entity(it.Handle->world, it.Handle->entities[i]), (T0*)pointer0, (T1*)pointer1, (T2*)pointer2, (T3*)pointer3, (T4*)pointer4, (T5*)pointer5, (T6*)pointer6, (T7*)pointer7, (T8*)pointer8, (T9*)pointer9, (T10*)pointer10, (T11*)pointer11))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerUnmanaged(i), field1.PointerUnmanaged(i), field2.PointerUnmanaged(i), field3.PointerUnmanaged(i), field4.PointerUnmanaged(i), field5.PointerUnmanaged(i), field6.PointerUnmanaged(i), field7.PointerUnmanaged(i), field8.PointerUnmanaged(i), field9.PointerUnmanaged(i), field10.PointerUnmanaged(i), field11.PointerUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSharedUnmanaged(i), field1.PointerSharedUnmanaged(i), field2.PointerSharedUnmanaged(i), field3.PointerSharedUnmanaged(i), field4.PointerSharedUnmanaged(i), field5.PointerSharedUnmanaged(i), field6.PointerSharedUnmanaged(i), field7.PointerSharedUnmanaged(i), field8.PointerSharedUnmanaged(i), field9.PointerSharedUnmanaged(i), field10.PointerSharedUnmanaged(i), field11.PointerSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseUnmanaged(i), field1.PointerSparseUnmanaged(i), field2.PointerSparseUnmanaged(i), field3.PointerSparseUnmanaged(i), field4.PointerSparseUnmanaged(i), field5.PointerSparseUnmanaged(i), field6.PointerSparseUnmanaged(i), field7.PointerSparseUnmanaged(i), field8.PointerSparseUnmanaged(i), field9.PointerSparseUnmanaged(i), field10.PointerSparseUnmanaged(i), field11.PointerSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseSharedUnmanaged(i), field1.PointerSparseSharedUnmanaged(i), field2.PointerSparseSharedUnmanaged(i), field3.PointerSparseSharedUnmanaged(i), field4.PointerSparseSharedUnmanaged(i), field5.PointerSparseSharedUnmanaged(i), field6.PointerSparseSharedUnmanaged(i), field7.PointerSparseSharedUnmanaged(i), field8.PointerSparseSharedUnmanaged(i), field9.PointerSparseSharedUnmanaged(i), field10.PointerSparseSharedUnmanaged(i), field11.PointerSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerManaged(i), field1.PointerManaged(i), field2.PointerManaged(i), field3.PointerManaged(i), field4.PointerManaged(i), field5.PointerManaged(i), field6.PointerManaged(i), field7.PointerManaged(i), field8.PointerManaged(i), field9.PointerManaged(i), field10.PointerManaged(i), field11.PointerManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSharedManaged(i), field1.PointerSharedManaged(i), field2.PointerSharedManaged(i), field3.PointerSharedManaged(i), field4.PointerSharedManaged(i), field5.PointerSharedManaged(i), field6.PointerSharedManaged(i), field7.PointerSharedManaged(i), field8.PointerSharedManaged(i), field9.PointerSharedManaged(i), field10.PointerSharedManaged(i), field11.PointerSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseManaged(i), field1.PointerSparseManaged(i), field2.PointerSparseManaged(i), field3.PointerSparseManaged(i), field4.PointerSparseManaged(i), field5.PointerSparseManaged(i), field6.PointerSparseManaged(i), field7.PointerSparseManaged(i), field8.PointerSparseManaged(i), field9.PointerSparseManaged(i), field10.PointerSparseManaged(i), field11.PointerSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseSharedManaged(i), field1.PointerSparseSharedManaged(i), field2.PointerSparseSharedManaged(i), field3.PointerSparseSharedManaged(i), field4.PointerSparseSharedManaged(i), field5.PointerSparseSharedManaged(i), field6.PointerSparseSharedManaged(i), field7.PointerSparseSharedManaged(i), field8.PointerSparseSharedManaged(i), field9.PointerSparseSharedManaged(i), field10.PointerSparseSharedManaged(i), field11.PointerSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 
     /// <summary>
@@ -265,25 +1147,135 @@ public static Entity Find<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(Iter
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8); byte* pointer9 = (byte*)it.GetPointer<T9>(9); byte* pointer10 = (byte*)it.GetPointer<T10>(10); byte* pointer11 = (byte*)it.GetPointer<T11>(11);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8); int step9 = it.Step<T9>(9); int step10 = it.Step<T10>(10); int step11 = it.Step<T11>(11);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8); FieldData<T9> field9 = it.GetFieldData<T9>(9); FieldData<T10> field10 = it.GetFieldData<T10>(10); FieldData<T11> field11 = it.GetFieldData<T11>(11);
+        IterationTechnique flags = it.GetIterationTechnique(12);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8], pointer9 = &pointer9[step9], pointer10 = &pointer10[step10], pointer11 = &pointer11[step11])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>() || RuntimeHelpers.IsReferenceOrContainsReferences<T9>() || RuntimeHelpers.IsReferenceOrContainsReferences<T10>() || RuntimeHelpers.IsReferenceOrContainsReferences<T11>())
         {
-            if (!callback(it, i, (T0*)pointer0, (T1*)pointer1, (T2*)pointer2, (T3*)pointer3, (T4*)pointer4, (T5*)pointer5, (T6*)pointer6, (T7*)pointer7, (T8*)pointer8, (T9*)pointer9, (T10*)pointer10, (T11*)pointer11))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerUnmanaged(i), field1.PointerUnmanaged(i), field2.PointerUnmanaged(i), field3.PointerUnmanaged(i), field4.PointerUnmanaged(i), field5.PointerUnmanaged(i), field6.PointerUnmanaged(i), field7.PointerUnmanaged(i), field8.PointerUnmanaged(i), field9.PointerUnmanaged(i), field10.PointerUnmanaged(i), field11.PointerUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSharedUnmanaged(i), field1.PointerSharedUnmanaged(i), field2.PointerSharedUnmanaged(i), field3.PointerSharedUnmanaged(i), field4.PointerSharedUnmanaged(i), field5.PointerSharedUnmanaged(i), field6.PointerSharedUnmanaged(i), field7.PointerSharedUnmanaged(i), field8.PointerSharedUnmanaged(i), field9.PointerSharedUnmanaged(i), field10.PointerSharedUnmanaged(i), field11.PointerSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSparseUnmanaged(i), field1.PointerSparseUnmanaged(i), field2.PointerSparseUnmanaged(i), field3.PointerSparseUnmanaged(i), field4.PointerSparseUnmanaged(i), field5.PointerSparseUnmanaged(i), field6.PointerSparseUnmanaged(i), field7.PointerSparseUnmanaged(i), field8.PointerSparseUnmanaged(i), field9.PointerSparseUnmanaged(i), field10.PointerSparseUnmanaged(i), field11.PointerSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSparseSharedUnmanaged(i), field1.PointerSparseSharedUnmanaged(i), field2.PointerSparseSharedUnmanaged(i), field3.PointerSparseSharedUnmanaged(i), field4.PointerSparseSharedUnmanaged(i), field5.PointerSparseSharedUnmanaged(i), field6.PointerSparseSharedUnmanaged(i), field7.PointerSparseSharedUnmanaged(i), field8.PointerSparseSharedUnmanaged(i), field9.PointerSparseSharedUnmanaged(i), field10.PointerSparseSharedUnmanaged(i), field11.PointerSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerManaged(i), field1.PointerManaged(i), field2.PointerManaged(i), field3.PointerManaged(i), field4.PointerManaged(i), field5.PointerManaged(i), field6.PointerManaged(i), field7.PointerManaged(i), field8.PointerManaged(i), field9.PointerManaged(i), field10.PointerManaged(i), field11.PointerManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSharedManaged(i), field1.PointerSharedManaged(i), field2.PointerSharedManaged(i), field3.PointerSharedManaged(i), field4.PointerSharedManaged(i), field5.PointerSharedManaged(i), field6.PointerSharedManaged(i), field7.PointerSharedManaged(i), field8.PointerSharedManaged(i), field9.PointerSharedManaged(i), field10.PointerSharedManaged(i), field11.PointerSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSparseManaged(i), field1.PointerSparseManaged(i), field2.PointerSparseManaged(i), field3.PointerSparseManaged(i), field4.PointerSparseManaged(i), field5.PointerSparseManaged(i), field6.PointerSparseManaged(i), field7.PointerSparseManaged(i), field8.PointerSparseManaged(i), field9.PointerSparseManaged(i), field10.PointerSparseManaged(i), field11.PointerSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSparseSharedManaged(i), field1.PointerSparseSharedManaged(i), field2.PointerSparseSharedManaged(i), field3.PointerSparseSharedManaged(i), field4.PointerSparseSharedManaged(i), field5.PointerSparseSharedManaged(i), field6.PointerSparseSharedManaged(i), field7.PointerSparseSharedManaged(i), field8.PointerSparseSharedManaged(i), field9.PointerSparseSharedManaged(i), field10.PointerSparseSharedManaged(i), field11.PointerSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 
     /// <summary>
@@ -296,25 +1288,135 @@ public static Entity Find<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(Iter
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8); byte* pointer9 = (byte*)it.GetPointer<T9>(9); byte* pointer10 = (byte*)it.GetPointer<T10>(10); byte* pointer11 = (byte*)it.GetPointer<T11>(11);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8); int step9 = it.Step<T9>(9); int step10 = it.Step<T10>(10); int step11 = it.Step<T11>(11);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8); FieldData<T9> field9 = it.GetFieldData<T9>(9); FieldData<T10> field10 = it.GetFieldData<T10>(10); FieldData<T11> field11 = it.GetFieldData<T11>(11);
+        IterationTechnique flags = it.GetIterationTechnique(12);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8], pointer9 = &pointer9[step9], pointer10 = &pointer10[step10], pointer11 = &pointer11[step11])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>() || RuntimeHelpers.IsReferenceOrContainsReferences<T9>() || RuntimeHelpers.IsReferenceOrContainsReferences<T10>() || RuntimeHelpers.IsReferenceOrContainsReferences<T11>())
         {
-            if (!callback((T0*)pointer0, (T1*)pointer1, (T2*)pointer2, (T3*)pointer3, (T4*)pointer4, (T5*)pointer5, (T6*)pointer6, (T7*)pointer7, (T8*)pointer8, (T9*)pointer9, (T10*)pointer10, (T11*)pointer11))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerUnmanaged(i), field1.PointerUnmanaged(i), field2.PointerUnmanaged(i), field3.PointerUnmanaged(i), field4.PointerUnmanaged(i), field5.PointerUnmanaged(i), field6.PointerUnmanaged(i), field7.PointerUnmanaged(i), field8.PointerUnmanaged(i), field9.PointerUnmanaged(i), field10.PointerUnmanaged(i), field11.PointerUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSharedUnmanaged(i), field1.PointerSharedUnmanaged(i), field2.PointerSharedUnmanaged(i), field3.PointerSharedUnmanaged(i), field4.PointerSharedUnmanaged(i), field5.PointerSharedUnmanaged(i), field6.PointerSharedUnmanaged(i), field7.PointerSharedUnmanaged(i), field8.PointerSharedUnmanaged(i), field9.PointerSharedUnmanaged(i), field10.PointerSharedUnmanaged(i), field11.PointerSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSparseUnmanaged(i), field1.PointerSparseUnmanaged(i), field2.PointerSparseUnmanaged(i), field3.PointerSparseUnmanaged(i), field4.PointerSparseUnmanaged(i), field5.PointerSparseUnmanaged(i), field6.PointerSparseUnmanaged(i), field7.PointerSparseUnmanaged(i), field8.PointerSparseUnmanaged(i), field9.PointerSparseUnmanaged(i), field10.PointerSparseUnmanaged(i), field11.PointerSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSparseSharedUnmanaged(i), field1.PointerSparseSharedUnmanaged(i), field2.PointerSparseSharedUnmanaged(i), field3.PointerSparseSharedUnmanaged(i), field4.PointerSparseSharedUnmanaged(i), field5.PointerSparseSharedUnmanaged(i), field6.PointerSparseSharedUnmanaged(i), field7.PointerSparseSharedUnmanaged(i), field8.PointerSparseSharedUnmanaged(i), field9.PointerSparseSharedUnmanaged(i), field10.PointerSparseSharedUnmanaged(i), field11.PointerSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerManaged(i), field1.PointerManaged(i), field2.PointerManaged(i), field3.PointerManaged(i), field4.PointerManaged(i), field5.PointerManaged(i), field6.PointerManaged(i), field7.PointerManaged(i), field8.PointerManaged(i), field9.PointerManaged(i), field10.PointerManaged(i), field11.PointerManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSharedManaged(i), field1.PointerSharedManaged(i), field2.PointerSharedManaged(i), field3.PointerSharedManaged(i), field4.PointerSharedManaged(i), field5.PointerSharedManaged(i), field6.PointerSharedManaged(i), field7.PointerSharedManaged(i), field8.PointerSharedManaged(i), field9.PointerSharedManaged(i), field10.PointerSharedManaged(i), field11.PointerSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSparseManaged(i), field1.PointerSparseManaged(i), field2.PointerSparseManaged(i), field3.PointerSparseManaged(i), field4.PointerSparseManaged(i), field5.PointerSparseManaged(i), field6.PointerSparseManaged(i), field7.PointerSparseManaged(i), field8.PointerSparseManaged(i), field9.PointerSparseManaged(i), field10.PointerSparseManaged(i), field11.PointerSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSparseSharedManaged(i), field1.PointerSparseSharedManaged(i), field2.PointerSparseSharedManaged(i), field3.PointerSparseSharedManaged(i), field4.PointerSparseSharedManaged(i), field5.PointerSparseSharedManaged(i), field6.PointerSparseSharedManaged(i), field7.PointerSparseSharedManaged(i), field8.PointerSparseSharedManaged(i), field9.PointerSparseSharedManaged(i), field10.PointerSparseSharedManaged(i), field11.PointerSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 
     /// <summary>
@@ -327,25 +1429,135 @@ public static Entity Find<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(Iter
     {
         int count = it.Handle->count; Ecs.Assert(it.Handle->count > 0, "No entities returned, use Iter() or Each() without the entity argument instead.");
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8); byte* pointer9 = (byte*)it.GetPointer<T9>(9); byte* pointer10 = (byte*)it.GetPointer<T10>(10); byte* pointer11 = (byte*)it.GetPointer<T11>(11);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8); int step9 = it.Step<T9>(9); int step10 = it.Step<T10>(10); int step11 = it.Step<T11>(11);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8); FieldData<T9> field9 = it.GetFieldData<T9>(9); FieldData<T10> field10 = it.GetFieldData<T10>(10); FieldData<T11> field11 = it.GetFieldData<T11>(11);
+        IterationTechnique flags = it.GetIterationTechnique(12);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8], pointer9 = &pointer9[step9], pointer10 = &pointer10[step10], pointer11 = &pointer11[step11])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>() || RuntimeHelpers.IsReferenceOrContainsReferences<T9>() || RuntimeHelpers.IsReferenceOrContainsReferences<T10>() || RuntimeHelpers.IsReferenceOrContainsReferences<T11>())
         {
-            if (!callback(new Entity(it.Handle->world, it.Handle->entities[i]), (T0*)pointer0, (T1*)pointer1, (T2*)pointer2, (T3*)pointer3, (T4*)pointer4, (T5*)pointer5, (T6*)pointer6, (T7*)pointer7, (T8*)pointer8, (T9*)pointer9, (T10*)pointer10, (T11*)pointer11))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerUnmanaged(i), field1.PointerUnmanaged(i), field2.PointerUnmanaged(i), field3.PointerUnmanaged(i), field4.PointerUnmanaged(i), field5.PointerUnmanaged(i), field6.PointerUnmanaged(i), field7.PointerUnmanaged(i), field8.PointerUnmanaged(i), field9.PointerUnmanaged(i), field10.PointerUnmanaged(i), field11.PointerUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSharedUnmanaged(i), field1.PointerSharedUnmanaged(i), field2.PointerSharedUnmanaged(i), field3.PointerSharedUnmanaged(i), field4.PointerSharedUnmanaged(i), field5.PointerSharedUnmanaged(i), field6.PointerSharedUnmanaged(i), field7.PointerSharedUnmanaged(i), field8.PointerSharedUnmanaged(i), field9.PointerSharedUnmanaged(i), field10.PointerSharedUnmanaged(i), field11.PointerSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseUnmanaged(i), field1.PointerSparseUnmanaged(i), field2.PointerSparseUnmanaged(i), field3.PointerSparseUnmanaged(i), field4.PointerSparseUnmanaged(i), field5.PointerSparseUnmanaged(i), field6.PointerSparseUnmanaged(i), field7.PointerSparseUnmanaged(i), field8.PointerSparseUnmanaged(i), field9.PointerSparseUnmanaged(i), field10.PointerSparseUnmanaged(i), field11.PointerSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseSharedUnmanaged(i), field1.PointerSparseSharedUnmanaged(i), field2.PointerSparseSharedUnmanaged(i), field3.PointerSparseSharedUnmanaged(i), field4.PointerSparseSharedUnmanaged(i), field5.PointerSparseSharedUnmanaged(i), field6.PointerSparseSharedUnmanaged(i), field7.PointerSparseSharedUnmanaged(i), field8.PointerSparseSharedUnmanaged(i), field9.PointerSparseSharedUnmanaged(i), field10.PointerSparseSharedUnmanaged(i), field11.PointerSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerManaged(i), field1.PointerManaged(i), field2.PointerManaged(i), field3.PointerManaged(i), field4.PointerManaged(i), field5.PointerManaged(i), field6.PointerManaged(i), field7.PointerManaged(i), field8.PointerManaged(i), field9.PointerManaged(i), field10.PointerManaged(i), field11.PointerManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSharedManaged(i), field1.PointerSharedManaged(i), field2.PointerSharedManaged(i), field3.PointerSharedManaged(i), field4.PointerSharedManaged(i), field5.PointerSharedManaged(i), field6.PointerSharedManaged(i), field7.PointerSharedManaged(i), field8.PointerSharedManaged(i), field9.PointerSharedManaged(i), field10.PointerSharedManaged(i), field11.PointerSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseManaged(i), field1.PointerSparseManaged(i), field2.PointerSparseManaged(i), field3.PointerSparseManaged(i), field4.PointerSparseManaged(i), field5.PointerSparseManaged(i), field6.PointerSparseManaged(i), field7.PointerSparseManaged(i), field8.PointerSparseManaged(i), field9.PointerSparseManaged(i), field10.PointerSparseManaged(i), field11.PointerSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseSharedManaged(i), field1.PointerSparseSharedManaged(i), field2.PointerSparseSharedManaged(i), field3.PointerSparseSharedManaged(i), field4.PointerSparseSharedManaged(i), field5.PointerSparseSharedManaged(i), field6.PointerSparseSharedManaged(i), field7.PointerSparseSharedManaged(i), field8.PointerSparseSharedManaged(i), field9.PointerSparseSharedManaged(i), field10.PointerSparseSharedManaged(i), field11.PointerSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 
     /// <summary>
@@ -358,24 +1570,134 @@ public static Entity Find<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(Iter
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8); byte* pointer9 = (byte*)it.GetPointer<T9>(9); byte* pointer10 = (byte*)it.GetPointer<T10>(10); byte* pointer11 = (byte*)it.GetPointer<T11>(11);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8); int step9 = it.Step<T9>(9); int step10 = it.Step<T10>(10); int step11 = it.Step<T11>(11);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8); FieldData<T9> field9 = it.GetFieldData<T9>(9); FieldData<T10> field10 = it.GetFieldData<T10>(10); FieldData<T11> field11 = it.GetFieldData<T11>(11);
+        IterationTechnique flags = it.GetIterationTechnique(12);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8], pointer9 = &pointer9[step9], pointer10 = &pointer10[step10], pointer11 = &pointer11[step11])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>() || RuntimeHelpers.IsReferenceOrContainsReferences<T9>() || RuntimeHelpers.IsReferenceOrContainsReferences<T10>() || RuntimeHelpers.IsReferenceOrContainsReferences<T11>())
         {
-            if (!callback(it, i, (T0*)pointer0, (T1*)pointer1, (T2*)pointer2, (T3*)pointer3, (T4*)pointer4, (T5*)pointer5, (T6*)pointer6, (T7*)pointer7, (T8*)pointer8, (T9*)pointer9, (T10*)pointer10, (T11*)pointer11))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerUnmanaged(i), field1.PointerUnmanaged(i), field2.PointerUnmanaged(i), field3.PointerUnmanaged(i), field4.PointerUnmanaged(i), field5.PointerUnmanaged(i), field6.PointerUnmanaged(i), field7.PointerUnmanaged(i), field8.PointerUnmanaged(i), field9.PointerUnmanaged(i), field10.PointerUnmanaged(i), field11.PointerUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSharedUnmanaged(i), field1.PointerSharedUnmanaged(i), field2.PointerSharedUnmanaged(i), field3.PointerSharedUnmanaged(i), field4.PointerSharedUnmanaged(i), field5.PointerSharedUnmanaged(i), field6.PointerSharedUnmanaged(i), field7.PointerSharedUnmanaged(i), field8.PointerSharedUnmanaged(i), field9.PointerSharedUnmanaged(i), field10.PointerSharedUnmanaged(i), field11.PointerSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSparseUnmanaged(i), field1.PointerSparseUnmanaged(i), field2.PointerSparseUnmanaged(i), field3.PointerSparseUnmanaged(i), field4.PointerSparseUnmanaged(i), field5.PointerSparseUnmanaged(i), field6.PointerSparseUnmanaged(i), field7.PointerSparseUnmanaged(i), field8.PointerSparseUnmanaged(i), field9.PointerSparseUnmanaged(i), field10.PointerSparseUnmanaged(i), field11.PointerSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSparseSharedUnmanaged(i), field1.PointerSparseSharedUnmanaged(i), field2.PointerSparseSharedUnmanaged(i), field3.PointerSparseSharedUnmanaged(i), field4.PointerSparseSharedUnmanaged(i), field5.PointerSparseSharedUnmanaged(i), field6.PointerSparseSharedUnmanaged(i), field7.PointerSparseSharedUnmanaged(i), field8.PointerSparseSharedUnmanaged(i), field9.PointerSparseSharedUnmanaged(i), field10.PointerSparseSharedUnmanaged(i), field11.PointerSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerManaged(i), field1.PointerManaged(i), field2.PointerManaged(i), field3.PointerManaged(i), field4.PointerManaged(i), field5.PointerManaged(i), field6.PointerManaged(i), field7.PointerManaged(i), field8.PointerManaged(i), field9.PointerManaged(i), field10.PointerManaged(i), field11.PointerManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSharedManaged(i), field1.PointerSharedManaged(i), field2.PointerSharedManaged(i), field3.PointerSharedManaged(i), field4.PointerSharedManaged(i), field5.PointerSharedManaged(i), field6.PointerSharedManaged(i), field7.PointerSharedManaged(i), field8.PointerSharedManaged(i), field9.PointerSharedManaged(i), field10.PointerSharedManaged(i), field11.PointerSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSparseManaged(i), field1.PointerSparseManaged(i), field2.PointerSparseManaged(i), field3.PointerSparseManaged(i), field4.PointerSparseManaged(i), field5.PointerSparseManaged(i), field6.PointerSparseManaged(i), field7.PointerSparseManaged(i), field8.PointerSparseManaged(i), field9.PointerSparseManaged(i), field10.PointerSparseManaged(i), field11.PointerSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSparseSharedManaged(i), field1.PointerSparseSharedManaged(i), field2.PointerSparseSharedManaged(i), field3.PointerSparseSharedManaged(i), field4.PointerSparseSharedManaged(i), field5.PointerSparseSharedManaged(i), field6.PointerSparseSharedManaged(i), field7.PointerSparseSharedManaged(i), field8.PointerSparseSharedManaged(i), field9.PointerSparseSharedManaged(i), field10.PointerSparseSharedManaged(i), field11.PointerSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 }
\ No newline at end of file
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/Invoker/Find/Iterator/T13.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/Invoker/Find/Iterator/T13.g.cs
index 75b4cdc7..da1379bc 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/Invoker/Find/Iterator/T13.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/Invoker/Find/Iterator/T13.g.cs
@@ -1,5 +1,7 @@
 // Find/Iterator/T13.g.cs
 // File was auto-generated by /_/src/Flecs.NET.Codegen/Generators/Invoker.cs
+using System;
+using System.Runtime.CompilerServices;
 using Flecs.NET.Utilities;
 using static Flecs.NET.Bindings.flecs;
 
@@ -17,25 +19,135 @@ public static Entity Find<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8); byte* pointer9 = (byte*)it.GetPointer<T9>(9); byte* pointer10 = (byte*)it.GetPointer<T10>(10); byte* pointer11 = (byte*)it.GetPointer<T11>(11); byte* pointer12 = (byte*)it.GetPointer<T12>(12);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8); int step9 = it.Step<T9>(9); int step10 = it.Step<T10>(10); int step11 = it.Step<T11>(11); int step12 = it.Step<T12>(12);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8); FieldData<T9> field9 = it.GetFieldData<T9>(9); FieldData<T10> field10 = it.GetFieldData<T10>(10); FieldData<T11> field11 = it.GetFieldData<T11>(11); FieldData<T12> field12 = it.GetFieldData<T12>(12);
+        IterationTechnique flags = it.GetIterationTechnique(13);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8], pointer9 = &pointer9[step9], pointer10 = &pointer10[step10], pointer11 = &pointer11[step11], pointer12 = &pointer12[step12])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>() || RuntimeHelpers.IsReferenceOrContainsReferences<T9>() || RuntimeHelpers.IsReferenceOrContainsReferences<T10>() || RuntimeHelpers.IsReferenceOrContainsReferences<T11>() || RuntimeHelpers.IsReferenceOrContainsReferences<T12>())
         {
-            if (!callback(ref Managed.GetTypeRef<T0>(pointer0), ref Managed.GetTypeRef<T1>(pointer1), ref Managed.GetTypeRef<T2>(pointer2), ref Managed.GetTypeRef<T3>(pointer3), ref Managed.GetTypeRef<T4>(pointer4), ref Managed.GetTypeRef<T5>(pointer5), ref Managed.GetTypeRef<T6>(pointer6), ref Managed.GetTypeRef<T7>(pointer7), ref Managed.GetTypeRef<T8>(pointer8), ref Managed.GetTypeRef<T9>(pointer9), ref Managed.GetTypeRef<T10>(pointer10), ref Managed.GetTypeRef<T11>(pointer11), ref Managed.GetTypeRef<T12>(pointer12)))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, Ecs.FindRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefUnmanaged(i), ref field1.RefUnmanaged(i), ref field2.RefUnmanaged(i), ref field3.RefUnmanaged(i), ref field4.RefUnmanaged(i), ref field5.RefUnmanaged(i), ref field6.RefUnmanaged(i), ref field7.RefUnmanaged(i), ref field8.RefUnmanaged(i), ref field9.RefUnmanaged(i), ref field10.RefUnmanaged(i), ref field11.RefUnmanaged(i), ref field12.RefUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, Ecs.FindRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSharedUnmanaged(i), ref field1.RefSharedUnmanaged(i), ref field2.RefSharedUnmanaged(i), ref field3.RefSharedUnmanaged(i), ref field4.RefSharedUnmanaged(i), ref field5.RefSharedUnmanaged(i), ref field6.RefSharedUnmanaged(i), ref field7.RefSharedUnmanaged(i), ref field8.RefSharedUnmanaged(i), ref field9.RefSharedUnmanaged(i), ref field10.RefSharedUnmanaged(i), ref field11.RefSharedUnmanaged(i), ref field12.RefSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, Ecs.FindRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSparseUnmanaged(i), ref field1.RefSparseUnmanaged(i), ref field2.RefSparseUnmanaged(i), ref field3.RefSparseUnmanaged(i), ref field4.RefSparseUnmanaged(i), ref field5.RefSparseUnmanaged(i), ref field6.RefSparseUnmanaged(i), ref field7.RefSparseUnmanaged(i), ref field8.RefSparseUnmanaged(i), ref field9.RefSparseUnmanaged(i), ref field10.RefSparseUnmanaged(i), ref field11.RefSparseUnmanaged(i), ref field12.RefSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, Ecs.FindRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSparseSharedUnmanaged(i), ref field1.RefSparseSharedUnmanaged(i), ref field2.RefSparseSharedUnmanaged(i), ref field3.RefSparseSharedUnmanaged(i), ref field4.RefSparseSharedUnmanaged(i), ref field5.RefSparseSharedUnmanaged(i), ref field6.RefSparseSharedUnmanaged(i), ref field7.RefSparseSharedUnmanaged(i), ref field8.RefSparseSharedUnmanaged(i), ref field9.RefSparseSharedUnmanaged(i), ref field10.RefSparseSharedUnmanaged(i), ref field11.RefSparseSharedUnmanaged(i), ref field12.RefSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, Ecs.FindRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefManaged(i), ref field1.RefManaged(i), ref field2.RefManaged(i), ref field3.RefManaged(i), ref field4.RefManaged(i), ref field5.RefManaged(i), ref field6.RefManaged(i), ref field7.RefManaged(i), ref field8.RefManaged(i), ref field9.RefManaged(i), ref field10.RefManaged(i), ref field11.RefManaged(i), ref field12.RefManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, Ecs.FindRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSharedManaged(i), ref field1.RefSharedManaged(i), ref field2.RefSharedManaged(i), ref field3.RefSharedManaged(i), ref field4.RefSharedManaged(i), ref field5.RefSharedManaged(i), ref field6.RefSharedManaged(i), ref field7.RefSharedManaged(i), ref field8.RefSharedManaged(i), ref field9.RefSharedManaged(i), ref field10.RefSharedManaged(i), ref field11.RefSharedManaged(i), ref field12.RefSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, Ecs.FindRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSparseManaged(i), ref field1.RefSparseManaged(i), ref field2.RefSparseManaged(i), ref field3.RefSparseManaged(i), ref field4.RefSparseManaged(i), ref field5.RefSparseManaged(i), ref field6.RefSparseManaged(i), ref field7.RefSparseManaged(i), ref field8.RefSparseManaged(i), ref field9.RefSparseManaged(i), ref field10.RefSparseManaged(i), ref field11.RefSparseManaged(i), ref field12.RefSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, Ecs.FindRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSparseSharedManaged(i), ref field1.RefSparseSharedManaged(i), ref field2.RefSparseSharedManaged(i), ref field3.RefSparseSharedManaged(i), ref field4.RefSparseSharedManaged(i), ref field5.RefSparseSharedManaged(i), ref field6.RefSparseSharedManaged(i), ref field7.RefSparseSharedManaged(i), ref field8.RefSparseSharedManaged(i), ref field9.RefSparseSharedManaged(i), ref field10.RefSparseSharedManaged(i), ref field11.RefSparseSharedManaged(i), ref field12.RefSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 
     /// <summary>
@@ -48,25 +160,135 @@ public static Entity Find<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>
     {
         int count = it.Handle->count; Ecs.Assert(it.Handle->count > 0, "No entities returned, use Iter() or Each() without the entity argument instead.");
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8); byte* pointer9 = (byte*)it.GetPointer<T9>(9); byte* pointer10 = (byte*)it.GetPointer<T10>(10); byte* pointer11 = (byte*)it.GetPointer<T11>(11); byte* pointer12 = (byte*)it.GetPointer<T12>(12);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8); int step9 = it.Step<T9>(9); int step10 = it.Step<T10>(10); int step11 = it.Step<T11>(11); int step12 = it.Step<T12>(12);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8); FieldData<T9> field9 = it.GetFieldData<T9>(9); FieldData<T10> field10 = it.GetFieldData<T10>(10); FieldData<T11> field11 = it.GetFieldData<T11>(11); FieldData<T12> field12 = it.GetFieldData<T12>(12);
+        IterationTechnique flags = it.GetIterationTechnique(13);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8], pointer9 = &pointer9[step9], pointer10 = &pointer10[step10], pointer11 = &pointer11[step11], pointer12 = &pointer12[step12])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>() || RuntimeHelpers.IsReferenceOrContainsReferences<T9>() || RuntimeHelpers.IsReferenceOrContainsReferences<T10>() || RuntimeHelpers.IsReferenceOrContainsReferences<T11>() || RuntimeHelpers.IsReferenceOrContainsReferences<T12>())
         {
-            if (!callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref Managed.GetTypeRef<T0>(pointer0), ref Managed.GetTypeRef<T1>(pointer1), ref Managed.GetTypeRef<T2>(pointer2), ref Managed.GetTypeRef<T3>(pointer3), ref Managed.GetTypeRef<T4>(pointer4), ref Managed.GetTypeRef<T5>(pointer5), ref Managed.GetTypeRef<T6>(pointer6), ref Managed.GetTypeRef<T7>(pointer7), ref Managed.GetTypeRef<T8>(pointer8), ref Managed.GetTypeRef<T9>(pointer9), ref Managed.GetTypeRef<T10>(pointer10), ref Managed.GetTypeRef<T11>(pointer11), ref Managed.GetTypeRef<T12>(pointer12)))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefUnmanaged(i), ref field1.RefUnmanaged(i), ref field2.RefUnmanaged(i), ref field3.RefUnmanaged(i), ref field4.RefUnmanaged(i), ref field5.RefUnmanaged(i), ref field6.RefUnmanaged(i), ref field7.RefUnmanaged(i), ref field8.RefUnmanaged(i), ref field9.RefUnmanaged(i), ref field10.RefUnmanaged(i), ref field11.RefUnmanaged(i), ref field12.RefUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSharedUnmanaged(i), ref field1.RefSharedUnmanaged(i), ref field2.RefSharedUnmanaged(i), ref field3.RefSharedUnmanaged(i), ref field4.RefSharedUnmanaged(i), ref field5.RefSharedUnmanaged(i), ref field6.RefSharedUnmanaged(i), ref field7.RefSharedUnmanaged(i), ref field8.RefSharedUnmanaged(i), ref field9.RefSharedUnmanaged(i), ref field10.RefSharedUnmanaged(i), ref field11.RefSharedUnmanaged(i), ref field12.RefSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseUnmanaged(i), ref field1.RefSparseUnmanaged(i), ref field2.RefSparseUnmanaged(i), ref field3.RefSparseUnmanaged(i), ref field4.RefSparseUnmanaged(i), ref field5.RefSparseUnmanaged(i), ref field6.RefSparseUnmanaged(i), ref field7.RefSparseUnmanaged(i), ref field8.RefSparseUnmanaged(i), ref field9.RefSparseUnmanaged(i), ref field10.RefSparseUnmanaged(i), ref field11.RefSparseUnmanaged(i), ref field12.RefSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseSharedUnmanaged(i), ref field1.RefSparseSharedUnmanaged(i), ref field2.RefSparseSharedUnmanaged(i), ref field3.RefSparseSharedUnmanaged(i), ref field4.RefSparseSharedUnmanaged(i), ref field5.RefSparseSharedUnmanaged(i), ref field6.RefSparseSharedUnmanaged(i), ref field7.RefSparseSharedUnmanaged(i), ref field8.RefSparseSharedUnmanaged(i), ref field9.RefSparseSharedUnmanaged(i), ref field10.RefSparseSharedUnmanaged(i), ref field11.RefSparseSharedUnmanaged(i), ref field12.RefSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefManaged(i), ref field1.RefManaged(i), ref field2.RefManaged(i), ref field3.RefManaged(i), ref field4.RefManaged(i), ref field5.RefManaged(i), ref field6.RefManaged(i), ref field7.RefManaged(i), ref field8.RefManaged(i), ref field9.RefManaged(i), ref field10.RefManaged(i), ref field11.RefManaged(i), ref field12.RefManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSharedManaged(i), ref field1.RefSharedManaged(i), ref field2.RefSharedManaged(i), ref field3.RefSharedManaged(i), ref field4.RefSharedManaged(i), ref field5.RefSharedManaged(i), ref field6.RefSharedManaged(i), ref field7.RefSharedManaged(i), ref field8.RefSharedManaged(i), ref field9.RefSharedManaged(i), ref field10.RefSharedManaged(i), ref field11.RefSharedManaged(i), ref field12.RefSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseManaged(i), ref field1.RefSparseManaged(i), ref field2.RefSparseManaged(i), ref field3.RefSparseManaged(i), ref field4.RefSparseManaged(i), ref field5.RefSparseManaged(i), ref field6.RefSparseManaged(i), ref field7.RefSparseManaged(i), ref field8.RefSparseManaged(i), ref field9.RefSparseManaged(i), ref field10.RefSparseManaged(i), ref field11.RefSparseManaged(i), ref field12.RefSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseSharedManaged(i), ref field1.RefSparseSharedManaged(i), ref field2.RefSparseSharedManaged(i), ref field3.RefSparseSharedManaged(i), ref field4.RefSparseSharedManaged(i), ref field5.RefSparseSharedManaged(i), ref field6.RefSparseSharedManaged(i), ref field7.RefSparseSharedManaged(i), ref field8.RefSparseSharedManaged(i), ref field9.RefSparseSharedManaged(i), ref field10.RefSparseSharedManaged(i), ref field11.RefSparseSharedManaged(i), ref field12.RefSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 
     /// <summary>
@@ -79,25 +301,135 @@ public static Entity Find<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8); byte* pointer9 = (byte*)it.GetPointer<T9>(9); byte* pointer10 = (byte*)it.GetPointer<T10>(10); byte* pointer11 = (byte*)it.GetPointer<T11>(11); byte* pointer12 = (byte*)it.GetPointer<T12>(12);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8); int step9 = it.Step<T9>(9); int step10 = it.Step<T10>(10); int step11 = it.Step<T11>(11); int step12 = it.Step<T12>(12);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8); FieldData<T9> field9 = it.GetFieldData<T9>(9); FieldData<T10> field10 = it.GetFieldData<T10>(10); FieldData<T11> field11 = it.GetFieldData<T11>(11); FieldData<T12> field12 = it.GetFieldData<T12>(12);
+        IterationTechnique flags = it.GetIterationTechnique(13);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8], pointer9 = &pointer9[step9], pointer10 = &pointer10[step10], pointer11 = &pointer11[step11], pointer12 = &pointer12[step12])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>() || RuntimeHelpers.IsReferenceOrContainsReferences<T9>() || RuntimeHelpers.IsReferenceOrContainsReferences<T10>() || RuntimeHelpers.IsReferenceOrContainsReferences<T11>() || RuntimeHelpers.IsReferenceOrContainsReferences<T12>())
         {
-            if (!callback(it, i, ref Managed.GetTypeRef<T0>(pointer0), ref Managed.GetTypeRef<T1>(pointer1), ref Managed.GetTypeRef<T2>(pointer2), ref Managed.GetTypeRef<T3>(pointer3), ref Managed.GetTypeRef<T4>(pointer4), ref Managed.GetTypeRef<T5>(pointer5), ref Managed.GetTypeRef<T6>(pointer6), ref Managed.GetTypeRef<T7>(pointer7), ref Managed.GetTypeRef<T8>(pointer8), ref Managed.GetTypeRef<T9>(pointer9), ref Managed.GetTypeRef<T10>(pointer10), ref Managed.GetTypeRef<T11>(pointer11), ref Managed.GetTypeRef<T12>(pointer12)))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, Ecs.FindIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefUnmanaged(i), ref field1.RefUnmanaged(i), ref field2.RefUnmanaged(i), ref field3.RefUnmanaged(i), ref field4.RefUnmanaged(i), ref field5.RefUnmanaged(i), ref field6.RefUnmanaged(i), ref field7.RefUnmanaged(i), ref field8.RefUnmanaged(i), ref field9.RefUnmanaged(i), ref field10.RefUnmanaged(i), ref field11.RefUnmanaged(i), ref field12.RefUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, Ecs.FindIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSharedUnmanaged(i), ref field1.RefSharedUnmanaged(i), ref field2.RefSharedUnmanaged(i), ref field3.RefSharedUnmanaged(i), ref field4.RefSharedUnmanaged(i), ref field5.RefSharedUnmanaged(i), ref field6.RefSharedUnmanaged(i), ref field7.RefSharedUnmanaged(i), ref field8.RefSharedUnmanaged(i), ref field9.RefSharedUnmanaged(i), ref field10.RefSharedUnmanaged(i), ref field11.RefSharedUnmanaged(i), ref field12.RefSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, Ecs.FindIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSparseUnmanaged(i), ref field1.RefSparseUnmanaged(i), ref field2.RefSparseUnmanaged(i), ref field3.RefSparseUnmanaged(i), ref field4.RefSparseUnmanaged(i), ref field5.RefSparseUnmanaged(i), ref field6.RefSparseUnmanaged(i), ref field7.RefSparseUnmanaged(i), ref field8.RefSparseUnmanaged(i), ref field9.RefSparseUnmanaged(i), ref field10.RefSparseUnmanaged(i), ref field11.RefSparseUnmanaged(i), ref field12.RefSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, Ecs.FindIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSparseSharedUnmanaged(i), ref field1.RefSparseSharedUnmanaged(i), ref field2.RefSparseSharedUnmanaged(i), ref field3.RefSparseSharedUnmanaged(i), ref field4.RefSparseSharedUnmanaged(i), ref field5.RefSparseSharedUnmanaged(i), ref field6.RefSparseSharedUnmanaged(i), ref field7.RefSparseSharedUnmanaged(i), ref field8.RefSparseSharedUnmanaged(i), ref field9.RefSparseSharedUnmanaged(i), ref field10.RefSparseSharedUnmanaged(i), ref field11.RefSparseSharedUnmanaged(i), ref field12.RefSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, Ecs.FindIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefManaged(i), ref field1.RefManaged(i), ref field2.RefManaged(i), ref field3.RefManaged(i), ref field4.RefManaged(i), ref field5.RefManaged(i), ref field6.RefManaged(i), ref field7.RefManaged(i), ref field8.RefManaged(i), ref field9.RefManaged(i), ref field10.RefManaged(i), ref field11.RefManaged(i), ref field12.RefManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, Ecs.FindIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSharedManaged(i), ref field1.RefSharedManaged(i), ref field2.RefSharedManaged(i), ref field3.RefSharedManaged(i), ref field4.RefSharedManaged(i), ref field5.RefSharedManaged(i), ref field6.RefSharedManaged(i), ref field7.RefSharedManaged(i), ref field8.RefSharedManaged(i), ref field9.RefSharedManaged(i), ref field10.RefSharedManaged(i), ref field11.RefSharedManaged(i), ref field12.RefSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, Ecs.FindIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSparseManaged(i), ref field1.RefSparseManaged(i), ref field2.RefSparseManaged(i), ref field3.RefSparseManaged(i), ref field4.RefSparseManaged(i), ref field5.RefSparseManaged(i), ref field6.RefSparseManaged(i), ref field7.RefSparseManaged(i), ref field8.RefSparseManaged(i), ref field9.RefSparseManaged(i), ref field10.RefSparseManaged(i), ref field11.RefSparseManaged(i), ref field12.RefSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, Ecs.FindIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSparseSharedManaged(i), ref field1.RefSparseSharedManaged(i), ref field2.RefSparseSharedManaged(i), ref field3.RefSparseSharedManaged(i), ref field4.RefSparseSharedManaged(i), ref field5.RefSparseSharedManaged(i), ref field6.RefSparseSharedManaged(i), ref field7.RefSparseSharedManaged(i), ref field8.RefSparseSharedManaged(i), ref field9.RefSparseSharedManaged(i), ref field10.RefSparseSharedManaged(i), ref field11.RefSparseSharedManaged(i), ref field12.RefSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 
     /// <summary>
@@ -110,25 +442,135 @@ public static Entity Find<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8); byte* pointer9 = (byte*)it.GetPointer<T9>(9); byte* pointer10 = (byte*)it.GetPointer<T10>(10); byte* pointer11 = (byte*)it.GetPointer<T11>(11); byte* pointer12 = (byte*)it.GetPointer<T12>(12);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8); int step9 = it.Step<T9>(9); int step10 = it.Step<T10>(10); int step11 = it.Step<T11>(11); int step12 = it.Step<T12>(12);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8); FieldData<T9> field9 = it.GetFieldData<T9>(9); FieldData<T10> field10 = it.GetFieldData<T10>(10); FieldData<T11> field11 = it.GetFieldData<T11>(11); FieldData<T12> field12 = it.GetFieldData<T12>(12);
+        IterationTechnique flags = it.GetIterationTechnique(13);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8], pointer9 = &pointer9[step9], pointer10 = &pointer10[step10], pointer11 = &pointer11[step11], pointer12 = &pointer12[step12])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>() || RuntimeHelpers.IsReferenceOrContainsReferences<T9>() || RuntimeHelpers.IsReferenceOrContainsReferences<T10>() || RuntimeHelpers.IsReferenceOrContainsReferences<T11>() || RuntimeHelpers.IsReferenceOrContainsReferences<T12>())
         {
-            if (!callback(ref Managed.GetTypeRef<T0>(pointer0), ref Managed.GetTypeRef<T1>(pointer1), ref Managed.GetTypeRef<T2>(pointer2), ref Managed.GetTypeRef<T3>(pointer3), ref Managed.GetTypeRef<T4>(pointer4), ref Managed.GetTypeRef<T5>(pointer5), ref Managed.GetTypeRef<T6>(pointer6), ref Managed.GetTypeRef<T7>(pointer7), ref Managed.GetTypeRef<T8>(pointer8), ref Managed.GetTypeRef<T9>(pointer9), ref Managed.GetTypeRef<T10>(pointer10), ref Managed.GetTypeRef<T11>(pointer11), ref Managed.GetTypeRef<T12>(pointer12)))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefUnmanaged(i), ref field1.RefUnmanaged(i), ref field2.RefUnmanaged(i), ref field3.RefUnmanaged(i), ref field4.RefUnmanaged(i), ref field5.RefUnmanaged(i), ref field6.RefUnmanaged(i), ref field7.RefUnmanaged(i), ref field8.RefUnmanaged(i), ref field9.RefUnmanaged(i), ref field10.RefUnmanaged(i), ref field11.RefUnmanaged(i), ref field12.RefUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSharedUnmanaged(i), ref field1.RefSharedUnmanaged(i), ref field2.RefSharedUnmanaged(i), ref field3.RefSharedUnmanaged(i), ref field4.RefSharedUnmanaged(i), ref field5.RefSharedUnmanaged(i), ref field6.RefSharedUnmanaged(i), ref field7.RefSharedUnmanaged(i), ref field8.RefSharedUnmanaged(i), ref field9.RefSharedUnmanaged(i), ref field10.RefSharedUnmanaged(i), ref field11.RefSharedUnmanaged(i), ref field12.RefSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSparseUnmanaged(i), ref field1.RefSparseUnmanaged(i), ref field2.RefSparseUnmanaged(i), ref field3.RefSparseUnmanaged(i), ref field4.RefSparseUnmanaged(i), ref field5.RefSparseUnmanaged(i), ref field6.RefSparseUnmanaged(i), ref field7.RefSparseUnmanaged(i), ref field8.RefSparseUnmanaged(i), ref field9.RefSparseUnmanaged(i), ref field10.RefSparseUnmanaged(i), ref field11.RefSparseUnmanaged(i), ref field12.RefSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSparseSharedUnmanaged(i), ref field1.RefSparseSharedUnmanaged(i), ref field2.RefSparseSharedUnmanaged(i), ref field3.RefSparseSharedUnmanaged(i), ref field4.RefSparseSharedUnmanaged(i), ref field5.RefSparseSharedUnmanaged(i), ref field6.RefSparseSharedUnmanaged(i), ref field7.RefSparseSharedUnmanaged(i), ref field8.RefSparseSharedUnmanaged(i), ref field9.RefSparseSharedUnmanaged(i), ref field10.RefSparseSharedUnmanaged(i), ref field11.RefSparseSharedUnmanaged(i), ref field12.RefSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefManaged(i), ref field1.RefManaged(i), ref field2.RefManaged(i), ref field3.RefManaged(i), ref field4.RefManaged(i), ref field5.RefManaged(i), ref field6.RefManaged(i), ref field7.RefManaged(i), ref field8.RefManaged(i), ref field9.RefManaged(i), ref field10.RefManaged(i), ref field11.RefManaged(i), ref field12.RefManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSharedManaged(i), ref field1.RefSharedManaged(i), ref field2.RefSharedManaged(i), ref field3.RefSharedManaged(i), ref field4.RefSharedManaged(i), ref field5.RefSharedManaged(i), ref field6.RefSharedManaged(i), ref field7.RefSharedManaged(i), ref field8.RefSharedManaged(i), ref field9.RefSharedManaged(i), ref field10.RefSharedManaged(i), ref field11.RefSharedManaged(i), ref field12.RefSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSparseManaged(i), ref field1.RefSparseManaged(i), ref field2.RefSparseManaged(i), ref field3.RefSparseManaged(i), ref field4.RefSparseManaged(i), ref field5.RefSparseManaged(i), ref field6.RefSparseManaged(i), ref field7.RefSparseManaged(i), ref field8.RefSparseManaged(i), ref field9.RefSparseManaged(i), ref field10.RefSparseManaged(i), ref field11.RefSparseManaged(i), ref field12.RefSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSparseSharedManaged(i), ref field1.RefSparseSharedManaged(i), ref field2.RefSparseSharedManaged(i), ref field3.RefSparseSharedManaged(i), ref field4.RefSparseSharedManaged(i), ref field5.RefSparseSharedManaged(i), ref field6.RefSparseSharedManaged(i), ref field7.RefSparseSharedManaged(i), ref field8.RefSparseSharedManaged(i), ref field9.RefSparseSharedManaged(i), ref field10.RefSparseSharedManaged(i), ref field11.RefSparseSharedManaged(i), ref field12.RefSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 
     /// <summary>
@@ -141,25 +583,135 @@ public static Entity Find<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>
     {
         int count = it.Handle->count; Ecs.Assert(it.Handle->count > 0, "No entities returned, use Iter() or Each() without the entity argument instead.");
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8); byte* pointer9 = (byte*)it.GetPointer<T9>(9); byte* pointer10 = (byte*)it.GetPointer<T10>(10); byte* pointer11 = (byte*)it.GetPointer<T11>(11); byte* pointer12 = (byte*)it.GetPointer<T12>(12);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8); int step9 = it.Step<T9>(9); int step10 = it.Step<T10>(10); int step11 = it.Step<T11>(11); int step12 = it.Step<T12>(12);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8); FieldData<T9> field9 = it.GetFieldData<T9>(9); FieldData<T10> field10 = it.GetFieldData<T10>(10); FieldData<T11> field11 = it.GetFieldData<T11>(11); FieldData<T12> field12 = it.GetFieldData<T12>(12);
+        IterationTechnique flags = it.GetIterationTechnique(13);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8], pointer9 = &pointer9[step9], pointer10 = &pointer10[step10], pointer11 = &pointer11[step11], pointer12 = &pointer12[step12])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>() || RuntimeHelpers.IsReferenceOrContainsReferences<T9>() || RuntimeHelpers.IsReferenceOrContainsReferences<T10>() || RuntimeHelpers.IsReferenceOrContainsReferences<T11>() || RuntimeHelpers.IsReferenceOrContainsReferences<T12>())
         {
-            if (!callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref Managed.GetTypeRef<T0>(pointer0), ref Managed.GetTypeRef<T1>(pointer1), ref Managed.GetTypeRef<T2>(pointer2), ref Managed.GetTypeRef<T3>(pointer3), ref Managed.GetTypeRef<T4>(pointer4), ref Managed.GetTypeRef<T5>(pointer5), ref Managed.GetTypeRef<T6>(pointer6), ref Managed.GetTypeRef<T7>(pointer7), ref Managed.GetTypeRef<T8>(pointer8), ref Managed.GetTypeRef<T9>(pointer9), ref Managed.GetTypeRef<T10>(pointer10), ref Managed.GetTypeRef<T11>(pointer11), ref Managed.GetTypeRef<T12>(pointer12)))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefUnmanaged(i), ref field1.RefUnmanaged(i), ref field2.RefUnmanaged(i), ref field3.RefUnmanaged(i), ref field4.RefUnmanaged(i), ref field5.RefUnmanaged(i), ref field6.RefUnmanaged(i), ref field7.RefUnmanaged(i), ref field8.RefUnmanaged(i), ref field9.RefUnmanaged(i), ref field10.RefUnmanaged(i), ref field11.RefUnmanaged(i), ref field12.RefUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSharedUnmanaged(i), ref field1.RefSharedUnmanaged(i), ref field2.RefSharedUnmanaged(i), ref field3.RefSharedUnmanaged(i), ref field4.RefSharedUnmanaged(i), ref field5.RefSharedUnmanaged(i), ref field6.RefSharedUnmanaged(i), ref field7.RefSharedUnmanaged(i), ref field8.RefSharedUnmanaged(i), ref field9.RefSharedUnmanaged(i), ref field10.RefSharedUnmanaged(i), ref field11.RefSharedUnmanaged(i), ref field12.RefSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseUnmanaged(i), ref field1.RefSparseUnmanaged(i), ref field2.RefSparseUnmanaged(i), ref field3.RefSparseUnmanaged(i), ref field4.RefSparseUnmanaged(i), ref field5.RefSparseUnmanaged(i), ref field6.RefSparseUnmanaged(i), ref field7.RefSparseUnmanaged(i), ref field8.RefSparseUnmanaged(i), ref field9.RefSparseUnmanaged(i), ref field10.RefSparseUnmanaged(i), ref field11.RefSparseUnmanaged(i), ref field12.RefSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseSharedUnmanaged(i), ref field1.RefSparseSharedUnmanaged(i), ref field2.RefSparseSharedUnmanaged(i), ref field3.RefSparseSharedUnmanaged(i), ref field4.RefSparseSharedUnmanaged(i), ref field5.RefSparseSharedUnmanaged(i), ref field6.RefSparseSharedUnmanaged(i), ref field7.RefSparseSharedUnmanaged(i), ref field8.RefSparseSharedUnmanaged(i), ref field9.RefSparseSharedUnmanaged(i), ref field10.RefSparseSharedUnmanaged(i), ref field11.RefSparseSharedUnmanaged(i), ref field12.RefSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefManaged(i), ref field1.RefManaged(i), ref field2.RefManaged(i), ref field3.RefManaged(i), ref field4.RefManaged(i), ref field5.RefManaged(i), ref field6.RefManaged(i), ref field7.RefManaged(i), ref field8.RefManaged(i), ref field9.RefManaged(i), ref field10.RefManaged(i), ref field11.RefManaged(i), ref field12.RefManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSharedManaged(i), ref field1.RefSharedManaged(i), ref field2.RefSharedManaged(i), ref field3.RefSharedManaged(i), ref field4.RefSharedManaged(i), ref field5.RefSharedManaged(i), ref field6.RefSharedManaged(i), ref field7.RefSharedManaged(i), ref field8.RefSharedManaged(i), ref field9.RefSharedManaged(i), ref field10.RefSharedManaged(i), ref field11.RefSharedManaged(i), ref field12.RefSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseManaged(i), ref field1.RefSparseManaged(i), ref field2.RefSparseManaged(i), ref field3.RefSparseManaged(i), ref field4.RefSparseManaged(i), ref field5.RefSparseManaged(i), ref field6.RefSparseManaged(i), ref field7.RefSparseManaged(i), ref field8.RefSparseManaged(i), ref field9.RefSparseManaged(i), ref field10.RefSparseManaged(i), ref field11.RefSparseManaged(i), ref field12.RefSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseSharedManaged(i), ref field1.RefSparseSharedManaged(i), ref field2.RefSparseSharedManaged(i), ref field3.RefSparseSharedManaged(i), ref field4.RefSparseSharedManaged(i), ref field5.RefSparseSharedManaged(i), ref field6.RefSparseSharedManaged(i), ref field7.RefSparseSharedManaged(i), ref field8.RefSparseSharedManaged(i), ref field9.RefSparseSharedManaged(i), ref field10.RefSparseSharedManaged(i), ref field11.RefSparseSharedManaged(i), ref field12.RefSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 
     /// <summary>
@@ -172,25 +724,135 @@ public static Entity Find<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8); byte* pointer9 = (byte*)it.GetPointer<T9>(9); byte* pointer10 = (byte*)it.GetPointer<T10>(10); byte* pointer11 = (byte*)it.GetPointer<T11>(11); byte* pointer12 = (byte*)it.GetPointer<T12>(12);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8); int step9 = it.Step<T9>(9); int step10 = it.Step<T10>(10); int step11 = it.Step<T11>(11); int step12 = it.Step<T12>(12);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8); FieldData<T9> field9 = it.GetFieldData<T9>(9); FieldData<T10> field10 = it.GetFieldData<T10>(10); FieldData<T11> field11 = it.GetFieldData<T11>(11); FieldData<T12> field12 = it.GetFieldData<T12>(12);
+        IterationTechnique flags = it.GetIterationTechnique(13);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8], pointer9 = &pointer9[step9], pointer10 = &pointer10[step10], pointer11 = &pointer11[step11], pointer12 = &pointer12[step12])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>() || RuntimeHelpers.IsReferenceOrContainsReferences<T9>() || RuntimeHelpers.IsReferenceOrContainsReferences<T10>() || RuntimeHelpers.IsReferenceOrContainsReferences<T11>() || RuntimeHelpers.IsReferenceOrContainsReferences<T12>())
         {
-            if (!callback(it, i, ref Managed.GetTypeRef<T0>(pointer0), ref Managed.GetTypeRef<T1>(pointer1), ref Managed.GetTypeRef<T2>(pointer2), ref Managed.GetTypeRef<T3>(pointer3), ref Managed.GetTypeRef<T4>(pointer4), ref Managed.GetTypeRef<T5>(pointer5), ref Managed.GetTypeRef<T6>(pointer6), ref Managed.GetTypeRef<T7>(pointer7), ref Managed.GetTypeRef<T8>(pointer8), ref Managed.GetTypeRef<T9>(pointer9), ref Managed.GetTypeRef<T10>(pointer10), ref Managed.GetTypeRef<T11>(pointer11), ref Managed.GetTypeRef<T12>(pointer12)))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefUnmanaged(i), ref field1.RefUnmanaged(i), ref field2.RefUnmanaged(i), ref field3.RefUnmanaged(i), ref field4.RefUnmanaged(i), ref field5.RefUnmanaged(i), ref field6.RefUnmanaged(i), ref field7.RefUnmanaged(i), ref field8.RefUnmanaged(i), ref field9.RefUnmanaged(i), ref field10.RefUnmanaged(i), ref field11.RefUnmanaged(i), ref field12.RefUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSharedUnmanaged(i), ref field1.RefSharedUnmanaged(i), ref field2.RefSharedUnmanaged(i), ref field3.RefSharedUnmanaged(i), ref field4.RefSharedUnmanaged(i), ref field5.RefSharedUnmanaged(i), ref field6.RefSharedUnmanaged(i), ref field7.RefSharedUnmanaged(i), ref field8.RefSharedUnmanaged(i), ref field9.RefSharedUnmanaged(i), ref field10.RefSharedUnmanaged(i), ref field11.RefSharedUnmanaged(i), ref field12.RefSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSparseUnmanaged(i), ref field1.RefSparseUnmanaged(i), ref field2.RefSparseUnmanaged(i), ref field3.RefSparseUnmanaged(i), ref field4.RefSparseUnmanaged(i), ref field5.RefSparseUnmanaged(i), ref field6.RefSparseUnmanaged(i), ref field7.RefSparseUnmanaged(i), ref field8.RefSparseUnmanaged(i), ref field9.RefSparseUnmanaged(i), ref field10.RefSparseUnmanaged(i), ref field11.RefSparseUnmanaged(i), ref field12.RefSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSparseSharedUnmanaged(i), ref field1.RefSparseSharedUnmanaged(i), ref field2.RefSparseSharedUnmanaged(i), ref field3.RefSparseSharedUnmanaged(i), ref field4.RefSparseSharedUnmanaged(i), ref field5.RefSparseSharedUnmanaged(i), ref field6.RefSparseSharedUnmanaged(i), ref field7.RefSparseSharedUnmanaged(i), ref field8.RefSparseSharedUnmanaged(i), ref field9.RefSparseSharedUnmanaged(i), ref field10.RefSparseSharedUnmanaged(i), ref field11.RefSparseSharedUnmanaged(i), ref field12.RefSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefManaged(i), ref field1.RefManaged(i), ref field2.RefManaged(i), ref field3.RefManaged(i), ref field4.RefManaged(i), ref field5.RefManaged(i), ref field6.RefManaged(i), ref field7.RefManaged(i), ref field8.RefManaged(i), ref field9.RefManaged(i), ref field10.RefManaged(i), ref field11.RefManaged(i), ref field12.RefManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSharedManaged(i), ref field1.RefSharedManaged(i), ref field2.RefSharedManaged(i), ref field3.RefSharedManaged(i), ref field4.RefSharedManaged(i), ref field5.RefSharedManaged(i), ref field6.RefSharedManaged(i), ref field7.RefSharedManaged(i), ref field8.RefSharedManaged(i), ref field9.RefSharedManaged(i), ref field10.RefSharedManaged(i), ref field11.RefSharedManaged(i), ref field12.RefSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSparseManaged(i), ref field1.RefSparseManaged(i), ref field2.RefSparseManaged(i), ref field3.RefSparseManaged(i), ref field4.RefSparseManaged(i), ref field5.RefSparseManaged(i), ref field6.RefSparseManaged(i), ref field7.RefSparseManaged(i), ref field8.RefSparseManaged(i), ref field9.RefSparseManaged(i), ref field10.RefSparseManaged(i), ref field11.RefSparseManaged(i), ref field12.RefSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSparseSharedManaged(i), ref field1.RefSparseSharedManaged(i), ref field2.RefSparseSharedManaged(i), ref field3.RefSparseSharedManaged(i), ref field4.RefSparseSharedManaged(i), ref field5.RefSparseSharedManaged(i), ref field6.RefSparseSharedManaged(i), ref field7.RefSparseSharedManaged(i), ref field8.RefSparseSharedManaged(i), ref field9.RefSparseSharedManaged(i), ref field10.RefSparseSharedManaged(i), ref field11.RefSparseSharedManaged(i), ref field12.RefSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 
     /// <summary>
@@ -203,25 +865,135 @@ public static Entity Find<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8); byte* pointer9 = (byte*)it.GetPointer<T9>(9); byte* pointer10 = (byte*)it.GetPointer<T10>(10); byte* pointer11 = (byte*)it.GetPointer<T11>(11); byte* pointer12 = (byte*)it.GetPointer<T12>(12);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8); int step9 = it.Step<T9>(9); int step10 = it.Step<T10>(10); int step11 = it.Step<T11>(11); int step12 = it.Step<T12>(12);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8); FieldData<T9> field9 = it.GetFieldData<T9>(9); FieldData<T10> field10 = it.GetFieldData<T10>(10); FieldData<T11> field11 = it.GetFieldData<T11>(11); FieldData<T12> field12 = it.GetFieldData<T12>(12);
+        IterationTechnique flags = it.GetIterationTechnique(13);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8], pointer9 = &pointer9[step9], pointer10 = &pointer10[step10], pointer11 = &pointer11[step11], pointer12 = &pointer12[step12])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>() || RuntimeHelpers.IsReferenceOrContainsReferences<T9>() || RuntimeHelpers.IsReferenceOrContainsReferences<T10>() || RuntimeHelpers.IsReferenceOrContainsReferences<T11>() || RuntimeHelpers.IsReferenceOrContainsReferences<T12>())
         {
-            if (!callback((T0*)pointer0, (T1*)pointer1, (T2*)pointer2, (T3*)pointer3, (T4*)pointer4, (T5*)pointer5, (T6*)pointer6, (T7*)pointer7, (T8*)pointer8, (T9*)pointer9, (T10*)pointer10, (T11*)pointer11, (T12*)pointer12))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, Ecs.FindPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerUnmanaged(i), field1.PointerUnmanaged(i), field2.PointerUnmanaged(i), field3.PointerUnmanaged(i), field4.PointerUnmanaged(i), field5.PointerUnmanaged(i), field6.PointerUnmanaged(i), field7.PointerUnmanaged(i), field8.PointerUnmanaged(i), field9.PointerUnmanaged(i), field10.PointerUnmanaged(i), field11.PointerUnmanaged(i), field12.PointerUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, Ecs.FindPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSharedUnmanaged(i), field1.PointerSharedUnmanaged(i), field2.PointerSharedUnmanaged(i), field3.PointerSharedUnmanaged(i), field4.PointerSharedUnmanaged(i), field5.PointerSharedUnmanaged(i), field6.PointerSharedUnmanaged(i), field7.PointerSharedUnmanaged(i), field8.PointerSharedUnmanaged(i), field9.PointerSharedUnmanaged(i), field10.PointerSharedUnmanaged(i), field11.PointerSharedUnmanaged(i), field12.PointerSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, Ecs.FindPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSparseUnmanaged(i), field1.PointerSparseUnmanaged(i), field2.PointerSparseUnmanaged(i), field3.PointerSparseUnmanaged(i), field4.PointerSparseUnmanaged(i), field5.PointerSparseUnmanaged(i), field6.PointerSparseUnmanaged(i), field7.PointerSparseUnmanaged(i), field8.PointerSparseUnmanaged(i), field9.PointerSparseUnmanaged(i), field10.PointerSparseUnmanaged(i), field11.PointerSparseUnmanaged(i), field12.PointerSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, Ecs.FindPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSparseSharedUnmanaged(i), field1.PointerSparseSharedUnmanaged(i), field2.PointerSparseSharedUnmanaged(i), field3.PointerSparseSharedUnmanaged(i), field4.PointerSparseSharedUnmanaged(i), field5.PointerSparseSharedUnmanaged(i), field6.PointerSparseSharedUnmanaged(i), field7.PointerSparseSharedUnmanaged(i), field8.PointerSparseSharedUnmanaged(i), field9.PointerSparseSharedUnmanaged(i), field10.PointerSparseSharedUnmanaged(i), field11.PointerSparseSharedUnmanaged(i), field12.PointerSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, Ecs.FindPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerManaged(i), field1.PointerManaged(i), field2.PointerManaged(i), field3.PointerManaged(i), field4.PointerManaged(i), field5.PointerManaged(i), field6.PointerManaged(i), field7.PointerManaged(i), field8.PointerManaged(i), field9.PointerManaged(i), field10.PointerManaged(i), field11.PointerManaged(i), field12.PointerManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, Ecs.FindPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSharedManaged(i), field1.PointerSharedManaged(i), field2.PointerSharedManaged(i), field3.PointerSharedManaged(i), field4.PointerSharedManaged(i), field5.PointerSharedManaged(i), field6.PointerSharedManaged(i), field7.PointerSharedManaged(i), field8.PointerSharedManaged(i), field9.PointerSharedManaged(i), field10.PointerSharedManaged(i), field11.PointerSharedManaged(i), field12.PointerSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, Ecs.FindPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSparseManaged(i), field1.PointerSparseManaged(i), field2.PointerSparseManaged(i), field3.PointerSparseManaged(i), field4.PointerSparseManaged(i), field5.PointerSparseManaged(i), field6.PointerSparseManaged(i), field7.PointerSparseManaged(i), field8.PointerSparseManaged(i), field9.PointerSparseManaged(i), field10.PointerSparseManaged(i), field11.PointerSparseManaged(i), field12.PointerSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, Ecs.FindPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSparseSharedManaged(i), field1.PointerSparseSharedManaged(i), field2.PointerSparseSharedManaged(i), field3.PointerSparseSharedManaged(i), field4.PointerSparseSharedManaged(i), field5.PointerSparseSharedManaged(i), field6.PointerSparseSharedManaged(i), field7.PointerSparseSharedManaged(i), field8.PointerSparseSharedManaged(i), field9.PointerSparseSharedManaged(i), field10.PointerSparseSharedManaged(i), field11.PointerSparseSharedManaged(i), field12.PointerSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 
     /// <summary>
@@ -234,25 +1006,135 @@ public static Entity Find<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>
     {
         int count = it.Handle->count; Ecs.Assert(it.Handle->count > 0, "No entities returned, use Iter() or Each() without the entity argument instead.");
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8); byte* pointer9 = (byte*)it.GetPointer<T9>(9); byte* pointer10 = (byte*)it.GetPointer<T10>(10); byte* pointer11 = (byte*)it.GetPointer<T11>(11); byte* pointer12 = (byte*)it.GetPointer<T12>(12);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8); int step9 = it.Step<T9>(9); int step10 = it.Step<T10>(10); int step11 = it.Step<T11>(11); int step12 = it.Step<T12>(12);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8); FieldData<T9> field9 = it.GetFieldData<T9>(9); FieldData<T10> field10 = it.GetFieldData<T10>(10); FieldData<T11> field11 = it.GetFieldData<T11>(11); FieldData<T12> field12 = it.GetFieldData<T12>(12);
+        IterationTechnique flags = it.GetIterationTechnique(13);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8], pointer9 = &pointer9[step9], pointer10 = &pointer10[step10], pointer11 = &pointer11[step11], pointer12 = &pointer12[step12])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>() || RuntimeHelpers.IsReferenceOrContainsReferences<T9>() || RuntimeHelpers.IsReferenceOrContainsReferences<T10>() || RuntimeHelpers.IsReferenceOrContainsReferences<T11>() || RuntimeHelpers.IsReferenceOrContainsReferences<T12>())
         {
-            if (!callback(new Entity(it.Handle->world, it.Handle->entities[i]), (T0*)pointer0, (T1*)pointer1, (T2*)pointer2, (T3*)pointer3, (T4*)pointer4, (T5*)pointer5, (T6*)pointer6, (T7*)pointer7, (T8*)pointer8, (T9*)pointer9, (T10*)pointer10, (T11*)pointer11, (T12*)pointer12))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerUnmanaged(i), field1.PointerUnmanaged(i), field2.PointerUnmanaged(i), field3.PointerUnmanaged(i), field4.PointerUnmanaged(i), field5.PointerUnmanaged(i), field6.PointerUnmanaged(i), field7.PointerUnmanaged(i), field8.PointerUnmanaged(i), field9.PointerUnmanaged(i), field10.PointerUnmanaged(i), field11.PointerUnmanaged(i), field12.PointerUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSharedUnmanaged(i), field1.PointerSharedUnmanaged(i), field2.PointerSharedUnmanaged(i), field3.PointerSharedUnmanaged(i), field4.PointerSharedUnmanaged(i), field5.PointerSharedUnmanaged(i), field6.PointerSharedUnmanaged(i), field7.PointerSharedUnmanaged(i), field8.PointerSharedUnmanaged(i), field9.PointerSharedUnmanaged(i), field10.PointerSharedUnmanaged(i), field11.PointerSharedUnmanaged(i), field12.PointerSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseUnmanaged(i), field1.PointerSparseUnmanaged(i), field2.PointerSparseUnmanaged(i), field3.PointerSparseUnmanaged(i), field4.PointerSparseUnmanaged(i), field5.PointerSparseUnmanaged(i), field6.PointerSparseUnmanaged(i), field7.PointerSparseUnmanaged(i), field8.PointerSparseUnmanaged(i), field9.PointerSparseUnmanaged(i), field10.PointerSparseUnmanaged(i), field11.PointerSparseUnmanaged(i), field12.PointerSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseSharedUnmanaged(i), field1.PointerSparseSharedUnmanaged(i), field2.PointerSparseSharedUnmanaged(i), field3.PointerSparseSharedUnmanaged(i), field4.PointerSparseSharedUnmanaged(i), field5.PointerSparseSharedUnmanaged(i), field6.PointerSparseSharedUnmanaged(i), field7.PointerSparseSharedUnmanaged(i), field8.PointerSparseSharedUnmanaged(i), field9.PointerSparseSharedUnmanaged(i), field10.PointerSparseSharedUnmanaged(i), field11.PointerSparseSharedUnmanaged(i), field12.PointerSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerManaged(i), field1.PointerManaged(i), field2.PointerManaged(i), field3.PointerManaged(i), field4.PointerManaged(i), field5.PointerManaged(i), field6.PointerManaged(i), field7.PointerManaged(i), field8.PointerManaged(i), field9.PointerManaged(i), field10.PointerManaged(i), field11.PointerManaged(i), field12.PointerManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSharedManaged(i), field1.PointerSharedManaged(i), field2.PointerSharedManaged(i), field3.PointerSharedManaged(i), field4.PointerSharedManaged(i), field5.PointerSharedManaged(i), field6.PointerSharedManaged(i), field7.PointerSharedManaged(i), field8.PointerSharedManaged(i), field9.PointerSharedManaged(i), field10.PointerSharedManaged(i), field11.PointerSharedManaged(i), field12.PointerSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseManaged(i), field1.PointerSparseManaged(i), field2.PointerSparseManaged(i), field3.PointerSparseManaged(i), field4.PointerSparseManaged(i), field5.PointerSparseManaged(i), field6.PointerSparseManaged(i), field7.PointerSparseManaged(i), field8.PointerSparseManaged(i), field9.PointerSparseManaged(i), field10.PointerSparseManaged(i), field11.PointerSparseManaged(i), field12.PointerSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseSharedManaged(i), field1.PointerSparseSharedManaged(i), field2.PointerSparseSharedManaged(i), field3.PointerSparseSharedManaged(i), field4.PointerSparseSharedManaged(i), field5.PointerSparseSharedManaged(i), field6.PointerSparseSharedManaged(i), field7.PointerSparseSharedManaged(i), field8.PointerSparseSharedManaged(i), field9.PointerSparseSharedManaged(i), field10.PointerSparseSharedManaged(i), field11.PointerSparseSharedManaged(i), field12.PointerSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 
     /// <summary>
@@ -265,25 +1147,135 @@ public static Entity Find<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8); byte* pointer9 = (byte*)it.GetPointer<T9>(9); byte* pointer10 = (byte*)it.GetPointer<T10>(10); byte* pointer11 = (byte*)it.GetPointer<T11>(11); byte* pointer12 = (byte*)it.GetPointer<T12>(12);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8); int step9 = it.Step<T9>(9); int step10 = it.Step<T10>(10); int step11 = it.Step<T11>(11); int step12 = it.Step<T12>(12);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8); FieldData<T9> field9 = it.GetFieldData<T9>(9); FieldData<T10> field10 = it.GetFieldData<T10>(10); FieldData<T11> field11 = it.GetFieldData<T11>(11); FieldData<T12> field12 = it.GetFieldData<T12>(12);
+        IterationTechnique flags = it.GetIterationTechnique(13);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8], pointer9 = &pointer9[step9], pointer10 = &pointer10[step10], pointer11 = &pointer11[step11], pointer12 = &pointer12[step12])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>() || RuntimeHelpers.IsReferenceOrContainsReferences<T9>() || RuntimeHelpers.IsReferenceOrContainsReferences<T10>() || RuntimeHelpers.IsReferenceOrContainsReferences<T11>() || RuntimeHelpers.IsReferenceOrContainsReferences<T12>())
         {
-            if (!callback(it, i, (T0*)pointer0, (T1*)pointer1, (T2*)pointer2, (T3*)pointer3, (T4*)pointer4, (T5*)pointer5, (T6*)pointer6, (T7*)pointer7, (T8*)pointer8, (T9*)pointer9, (T10*)pointer10, (T11*)pointer11, (T12*)pointer12))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerUnmanaged(i), field1.PointerUnmanaged(i), field2.PointerUnmanaged(i), field3.PointerUnmanaged(i), field4.PointerUnmanaged(i), field5.PointerUnmanaged(i), field6.PointerUnmanaged(i), field7.PointerUnmanaged(i), field8.PointerUnmanaged(i), field9.PointerUnmanaged(i), field10.PointerUnmanaged(i), field11.PointerUnmanaged(i), field12.PointerUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSharedUnmanaged(i), field1.PointerSharedUnmanaged(i), field2.PointerSharedUnmanaged(i), field3.PointerSharedUnmanaged(i), field4.PointerSharedUnmanaged(i), field5.PointerSharedUnmanaged(i), field6.PointerSharedUnmanaged(i), field7.PointerSharedUnmanaged(i), field8.PointerSharedUnmanaged(i), field9.PointerSharedUnmanaged(i), field10.PointerSharedUnmanaged(i), field11.PointerSharedUnmanaged(i), field12.PointerSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSparseUnmanaged(i), field1.PointerSparseUnmanaged(i), field2.PointerSparseUnmanaged(i), field3.PointerSparseUnmanaged(i), field4.PointerSparseUnmanaged(i), field5.PointerSparseUnmanaged(i), field6.PointerSparseUnmanaged(i), field7.PointerSparseUnmanaged(i), field8.PointerSparseUnmanaged(i), field9.PointerSparseUnmanaged(i), field10.PointerSparseUnmanaged(i), field11.PointerSparseUnmanaged(i), field12.PointerSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSparseSharedUnmanaged(i), field1.PointerSparseSharedUnmanaged(i), field2.PointerSparseSharedUnmanaged(i), field3.PointerSparseSharedUnmanaged(i), field4.PointerSparseSharedUnmanaged(i), field5.PointerSparseSharedUnmanaged(i), field6.PointerSparseSharedUnmanaged(i), field7.PointerSparseSharedUnmanaged(i), field8.PointerSparseSharedUnmanaged(i), field9.PointerSparseSharedUnmanaged(i), field10.PointerSparseSharedUnmanaged(i), field11.PointerSparseSharedUnmanaged(i), field12.PointerSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerManaged(i), field1.PointerManaged(i), field2.PointerManaged(i), field3.PointerManaged(i), field4.PointerManaged(i), field5.PointerManaged(i), field6.PointerManaged(i), field7.PointerManaged(i), field8.PointerManaged(i), field9.PointerManaged(i), field10.PointerManaged(i), field11.PointerManaged(i), field12.PointerManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSharedManaged(i), field1.PointerSharedManaged(i), field2.PointerSharedManaged(i), field3.PointerSharedManaged(i), field4.PointerSharedManaged(i), field5.PointerSharedManaged(i), field6.PointerSharedManaged(i), field7.PointerSharedManaged(i), field8.PointerSharedManaged(i), field9.PointerSharedManaged(i), field10.PointerSharedManaged(i), field11.PointerSharedManaged(i), field12.PointerSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSparseManaged(i), field1.PointerSparseManaged(i), field2.PointerSparseManaged(i), field3.PointerSparseManaged(i), field4.PointerSparseManaged(i), field5.PointerSparseManaged(i), field6.PointerSparseManaged(i), field7.PointerSparseManaged(i), field8.PointerSparseManaged(i), field9.PointerSparseManaged(i), field10.PointerSparseManaged(i), field11.PointerSparseManaged(i), field12.PointerSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSparseSharedManaged(i), field1.PointerSparseSharedManaged(i), field2.PointerSparseSharedManaged(i), field3.PointerSparseSharedManaged(i), field4.PointerSparseSharedManaged(i), field5.PointerSparseSharedManaged(i), field6.PointerSparseSharedManaged(i), field7.PointerSparseSharedManaged(i), field8.PointerSparseSharedManaged(i), field9.PointerSparseSharedManaged(i), field10.PointerSparseSharedManaged(i), field11.PointerSparseSharedManaged(i), field12.PointerSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 
     /// <summary>
@@ -296,25 +1288,135 @@ public static Entity Find<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8); byte* pointer9 = (byte*)it.GetPointer<T9>(9); byte* pointer10 = (byte*)it.GetPointer<T10>(10); byte* pointer11 = (byte*)it.GetPointer<T11>(11); byte* pointer12 = (byte*)it.GetPointer<T12>(12);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8); int step9 = it.Step<T9>(9); int step10 = it.Step<T10>(10); int step11 = it.Step<T11>(11); int step12 = it.Step<T12>(12);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8); FieldData<T9> field9 = it.GetFieldData<T9>(9); FieldData<T10> field10 = it.GetFieldData<T10>(10); FieldData<T11> field11 = it.GetFieldData<T11>(11); FieldData<T12> field12 = it.GetFieldData<T12>(12);
+        IterationTechnique flags = it.GetIterationTechnique(13);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8], pointer9 = &pointer9[step9], pointer10 = &pointer10[step10], pointer11 = &pointer11[step11], pointer12 = &pointer12[step12])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>() || RuntimeHelpers.IsReferenceOrContainsReferences<T9>() || RuntimeHelpers.IsReferenceOrContainsReferences<T10>() || RuntimeHelpers.IsReferenceOrContainsReferences<T11>() || RuntimeHelpers.IsReferenceOrContainsReferences<T12>())
         {
-            if (!callback((T0*)pointer0, (T1*)pointer1, (T2*)pointer2, (T3*)pointer3, (T4*)pointer4, (T5*)pointer5, (T6*)pointer6, (T7*)pointer7, (T8*)pointer8, (T9*)pointer9, (T10*)pointer10, (T11*)pointer11, (T12*)pointer12))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerUnmanaged(i), field1.PointerUnmanaged(i), field2.PointerUnmanaged(i), field3.PointerUnmanaged(i), field4.PointerUnmanaged(i), field5.PointerUnmanaged(i), field6.PointerUnmanaged(i), field7.PointerUnmanaged(i), field8.PointerUnmanaged(i), field9.PointerUnmanaged(i), field10.PointerUnmanaged(i), field11.PointerUnmanaged(i), field12.PointerUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSharedUnmanaged(i), field1.PointerSharedUnmanaged(i), field2.PointerSharedUnmanaged(i), field3.PointerSharedUnmanaged(i), field4.PointerSharedUnmanaged(i), field5.PointerSharedUnmanaged(i), field6.PointerSharedUnmanaged(i), field7.PointerSharedUnmanaged(i), field8.PointerSharedUnmanaged(i), field9.PointerSharedUnmanaged(i), field10.PointerSharedUnmanaged(i), field11.PointerSharedUnmanaged(i), field12.PointerSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSparseUnmanaged(i), field1.PointerSparseUnmanaged(i), field2.PointerSparseUnmanaged(i), field3.PointerSparseUnmanaged(i), field4.PointerSparseUnmanaged(i), field5.PointerSparseUnmanaged(i), field6.PointerSparseUnmanaged(i), field7.PointerSparseUnmanaged(i), field8.PointerSparseUnmanaged(i), field9.PointerSparseUnmanaged(i), field10.PointerSparseUnmanaged(i), field11.PointerSparseUnmanaged(i), field12.PointerSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSparseSharedUnmanaged(i), field1.PointerSparseSharedUnmanaged(i), field2.PointerSparseSharedUnmanaged(i), field3.PointerSparseSharedUnmanaged(i), field4.PointerSparseSharedUnmanaged(i), field5.PointerSparseSharedUnmanaged(i), field6.PointerSparseSharedUnmanaged(i), field7.PointerSparseSharedUnmanaged(i), field8.PointerSparseSharedUnmanaged(i), field9.PointerSparseSharedUnmanaged(i), field10.PointerSparseSharedUnmanaged(i), field11.PointerSparseSharedUnmanaged(i), field12.PointerSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerManaged(i), field1.PointerManaged(i), field2.PointerManaged(i), field3.PointerManaged(i), field4.PointerManaged(i), field5.PointerManaged(i), field6.PointerManaged(i), field7.PointerManaged(i), field8.PointerManaged(i), field9.PointerManaged(i), field10.PointerManaged(i), field11.PointerManaged(i), field12.PointerManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSharedManaged(i), field1.PointerSharedManaged(i), field2.PointerSharedManaged(i), field3.PointerSharedManaged(i), field4.PointerSharedManaged(i), field5.PointerSharedManaged(i), field6.PointerSharedManaged(i), field7.PointerSharedManaged(i), field8.PointerSharedManaged(i), field9.PointerSharedManaged(i), field10.PointerSharedManaged(i), field11.PointerSharedManaged(i), field12.PointerSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSparseManaged(i), field1.PointerSparseManaged(i), field2.PointerSparseManaged(i), field3.PointerSparseManaged(i), field4.PointerSparseManaged(i), field5.PointerSparseManaged(i), field6.PointerSparseManaged(i), field7.PointerSparseManaged(i), field8.PointerSparseManaged(i), field9.PointerSparseManaged(i), field10.PointerSparseManaged(i), field11.PointerSparseManaged(i), field12.PointerSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSparseSharedManaged(i), field1.PointerSparseSharedManaged(i), field2.PointerSparseSharedManaged(i), field3.PointerSparseSharedManaged(i), field4.PointerSparseSharedManaged(i), field5.PointerSparseSharedManaged(i), field6.PointerSparseSharedManaged(i), field7.PointerSparseSharedManaged(i), field8.PointerSparseSharedManaged(i), field9.PointerSparseSharedManaged(i), field10.PointerSparseSharedManaged(i), field11.PointerSparseSharedManaged(i), field12.PointerSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 
     /// <summary>
@@ -327,25 +1429,135 @@ public static Entity Find<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>
     {
         int count = it.Handle->count; Ecs.Assert(it.Handle->count > 0, "No entities returned, use Iter() or Each() without the entity argument instead.");
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8); byte* pointer9 = (byte*)it.GetPointer<T9>(9); byte* pointer10 = (byte*)it.GetPointer<T10>(10); byte* pointer11 = (byte*)it.GetPointer<T11>(11); byte* pointer12 = (byte*)it.GetPointer<T12>(12);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8); int step9 = it.Step<T9>(9); int step10 = it.Step<T10>(10); int step11 = it.Step<T11>(11); int step12 = it.Step<T12>(12);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8); FieldData<T9> field9 = it.GetFieldData<T9>(9); FieldData<T10> field10 = it.GetFieldData<T10>(10); FieldData<T11> field11 = it.GetFieldData<T11>(11); FieldData<T12> field12 = it.GetFieldData<T12>(12);
+        IterationTechnique flags = it.GetIterationTechnique(13);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8], pointer9 = &pointer9[step9], pointer10 = &pointer10[step10], pointer11 = &pointer11[step11], pointer12 = &pointer12[step12])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>() || RuntimeHelpers.IsReferenceOrContainsReferences<T9>() || RuntimeHelpers.IsReferenceOrContainsReferences<T10>() || RuntimeHelpers.IsReferenceOrContainsReferences<T11>() || RuntimeHelpers.IsReferenceOrContainsReferences<T12>())
         {
-            if (!callback(new Entity(it.Handle->world, it.Handle->entities[i]), (T0*)pointer0, (T1*)pointer1, (T2*)pointer2, (T3*)pointer3, (T4*)pointer4, (T5*)pointer5, (T6*)pointer6, (T7*)pointer7, (T8*)pointer8, (T9*)pointer9, (T10*)pointer10, (T11*)pointer11, (T12*)pointer12))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerUnmanaged(i), field1.PointerUnmanaged(i), field2.PointerUnmanaged(i), field3.PointerUnmanaged(i), field4.PointerUnmanaged(i), field5.PointerUnmanaged(i), field6.PointerUnmanaged(i), field7.PointerUnmanaged(i), field8.PointerUnmanaged(i), field9.PointerUnmanaged(i), field10.PointerUnmanaged(i), field11.PointerUnmanaged(i), field12.PointerUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSharedUnmanaged(i), field1.PointerSharedUnmanaged(i), field2.PointerSharedUnmanaged(i), field3.PointerSharedUnmanaged(i), field4.PointerSharedUnmanaged(i), field5.PointerSharedUnmanaged(i), field6.PointerSharedUnmanaged(i), field7.PointerSharedUnmanaged(i), field8.PointerSharedUnmanaged(i), field9.PointerSharedUnmanaged(i), field10.PointerSharedUnmanaged(i), field11.PointerSharedUnmanaged(i), field12.PointerSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseUnmanaged(i), field1.PointerSparseUnmanaged(i), field2.PointerSparseUnmanaged(i), field3.PointerSparseUnmanaged(i), field4.PointerSparseUnmanaged(i), field5.PointerSparseUnmanaged(i), field6.PointerSparseUnmanaged(i), field7.PointerSparseUnmanaged(i), field8.PointerSparseUnmanaged(i), field9.PointerSparseUnmanaged(i), field10.PointerSparseUnmanaged(i), field11.PointerSparseUnmanaged(i), field12.PointerSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseSharedUnmanaged(i), field1.PointerSparseSharedUnmanaged(i), field2.PointerSparseSharedUnmanaged(i), field3.PointerSparseSharedUnmanaged(i), field4.PointerSparseSharedUnmanaged(i), field5.PointerSparseSharedUnmanaged(i), field6.PointerSparseSharedUnmanaged(i), field7.PointerSparseSharedUnmanaged(i), field8.PointerSparseSharedUnmanaged(i), field9.PointerSparseSharedUnmanaged(i), field10.PointerSparseSharedUnmanaged(i), field11.PointerSparseSharedUnmanaged(i), field12.PointerSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerManaged(i), field1.PointerManaged(i), field2.PointerManaged(i), field3.PointerManaged(i), field4.PointerManaged(i), field5.PointerManaged(i), field6.PointerManaged(i), field7.PointerManaged(i), field8.PointerManaged(i), field9.PointerManaged(i), field10.PointerManaged(i), field11.PointerManaged(i), field12.PointerManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSharedManaged(i), field1.PointerSharedManaged(i), field2.PointerSharedManaged(i), field3.PointerSharedManaged(i), field4.PointerSharedManaged(i), field5.PointerSharedManaged(i), field6.PointerSharedManaged(i), field7.PointerSharedManaged(i), field8.PointerSharedManaged(i), field9.PointerSharedManaged(i), field10.PointerSharedManaged(i), field11.PointerSharedManaged(i), field12.PointerSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseManaged(i), field1.PointerSparseManaged(i), field2.PointerSparseManaged(i), field3.PointerSparseManaged(i), field4.PointerSparseManaged(i), field5.PointerSparseManaged(i), field6.PointerSparseManaged(i), field7.PointerSparseManaged(i), field8.PointerSparseManaged(i), field9.PointerSparseManaged(i), field10.PointerSparseManaged(i), field11.PointerSparseManaged(i), field12.PointerSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseSharedManaged(i), field1.PointerSparseSharedManaged(i), field2.PointerSparseSharedManaged(i), field3.PointerSparseSharedManaged(i), field4.PointerSparseSharedManaged(i), field5.PointerSparseSharedManaged(i), field6.PointerSparseSharedManaged(i), field7.PointerSparseSharedManaged(i), field8.PointerSparseSharedManaged(i), field9.PointerSparseSharedManaged(i), field10.PointerSparseSharedManaged(i), field11.PointerSparseSharedManaged(i), field12.PointerSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 
     /// <summary>
@@ -358,24 +1570,134 @@ public static Entity Find<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8); byte* pointer9 = (byte*)it.GetPointer<T9>(9); byte* pointer10 = (byte*)it.GetPointer<T10>(10); byte* pointer11 = (byte*)it.GetPointer<T11>(11); byte* pointer12 = (byte*)it.GetPointer<T12>(12);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8); int step9 = it.Step<T9>(9); int step10 = it.Step<T10>(10); int step11 = it.Step<T11>(11); int step12 = it.Step<T12>(12);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8); FieldData<T9> field9 = it.GetFieldData<T9>(9); FieldData<T10> field10 = it.GetFieldData<T10>(10); FieldData<T11> field11 = it.GetFieldData<T11>(11); FieldData<T12> field12 = it.GetFieldData<T12>(12);
+        IterationTechnique flags = it.GetIterationTechnique(13);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8], pointer9 = &pointer9[step9], pointer10 = &pointer10[step10], pointer11 = &pointer11[step11], pointer12 = &pointer12[step12])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>() || RuntimeHelpers.IsReferenceOrContainsReferences<T9>() || RuntimeHelpers.IsReferenceOrContainsReferences<T10>() || RuntimeHelpers.IsReferenceOrContainsReferences<T11>() || RuntimeHelpers.IsReferenceOrContainsReferences<T12>())
         {
-            if (!callback(it, i, (T0*)pointer0, (T1*)pointer1, (T2*)pointer2, (T3*)pointer3, (T4*)pointer4, (T5*)pointer5, (T6*)pointer6, (T7*)pointer7, (T8*)pointer8, (T9*)pointer9, (T10*)pointer10, (T11*)pointer11, (T12*)pointer12))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerUnmanaged(i), field1.PointerUnmanaged(i), field2.PointerUnmanaged(i), field3.PointerUnmanaged(i), field4.PointerUnmanaged(i), field5.PointerUnmanaged(i), field6.PointerUnmanaged(i), field7.PointerUnmanaged(i), field8.PointerUnmanaged(i), field9.PointerUnmanaged(i), field10.PointerUnmanaged(i), field11.PointerUnmanaged(i), field12.PointerUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSharedUnmanaged(i), field1.PointerSharedUnmanaged(i), field2.PointerSharedUnmanaged(i), field3.PointerSharedUnmanaged(i), field4.PointerSharedUnmanaged(i), field5.PointerSharedUnmanaged(i), field6.PointerSharedUnmanaged(i), field7.PointerSharedUnmanaged(i), field8.PointerSharedUnmanaged(i), field9.PointerSharedUnmanaged(i), field10.PointerSharedUnmanaged(i), field11.PointerSharedUnmanaged(i), field12.PointerSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSparseUnmanaged(i), field1.PointerSparseUnmanaged(i), field2.PointerSparseUnmanaged(i), field3.PointerSparseUnmanaged(i), field4.PointerSparseUnmanaged(i), field5.PointerSparseUnmanaged(i), field6.PointerSparseUnmanaged(i), field7.PointerSparseUnmanaged(i), field8.PointerSparseUnmanaged(i), field9.PointerSparseUnmanaged(i), field10.PointerSparseUnmanaged(i), field11.PointerSparseUnmanaged(i), field12.PointerSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSparseSharedUnmanaged(i), field1.PointerSparseSharedUnmanaged(i), field2.PointerSparseSharedUnmanaged(i), field3.PointerSparseSharedUnmanaged(i), field4.PointerSparseSharedUnmanaged(i), field5.PointerSparseSharedUnmanaged(i), field6.PointerSparseSharedUnmanaged(i), field7.PointerSparseSharedUnmanaged(i), field8.PointerSparseSharedUnmanaged(i), field9.PointerSparseSharedUnmanaged(i), field10.PointerSparseSharedUnmanaged(i), field11.PointerSparseSharedUnmanaged(i), field12.PointerSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerManaged(i), field1.PointerManaged(i), field2.PointerManaged(i), field3.PointerManaged(i), field4.PointerManaged(i), field5.PointerManaged(i), field6.PointerManaged(i), field7.PointerManaged(i), field8.PointerManaged(i), field9.PointerManaged(i), field10.PointerManaged(i), field11.PointerManaged(i), field12.PointerManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSharedManaged(i), field1.PointerSharedManaged(i), field2.PointerSharedManaged(i), field3.PointerSharedManaged(i), field4.PointerSharedManaged(i), field5.PointerSharedManaged(i), field6.PointerSharedManaged(i), field7.PointerSharedManaged(i), field8.PointerSharedManaged(i), field9.PointerSharedManaged(i), field10.PointerSharedManaged(i), field11.PointerSharedManaged(i), field12.PointerSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSparseManaged(i), field1.PointerSparseManaged(i), field2.PointerSparseManaged(i), field3.PointerSparseManaged(i), field4.PointerSparseManaged(i), field5.PointerSparseManaged(i), field6.PointerSparseManaged(i), field7.PointerSparseManaged(i), field8.PointerSparseManaged(i), field9.PointerSparseManaged(i), field10.PointerSparseManaged(i), field11.PointerSparseManaged(i), field12.PointerSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSparseSharedManaged(i), field1.PointerSparseSharedManaged(i), field2.PointerSparseSharedManaged(i), field3.PointerSparseSharedManaged(i), field4.PointerSparseSharedManaged(i), field5.PointerSparseSharedManaged(i), field6.PointerSparseSharedManaged(i), field7.PointerSparseSharedManaged(i), field8.PointerSparseSharedManaged(i), field9.PointerSparseSharedManaged(i), field10.PointerSparseSharedManaged(i), field11.PointerSparseSharedManaged(i), field12.PointerSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 }
\ No newline at end of file
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/Invoker/Find/Iterator/T14.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/Invoker/Find/Iterator/T14.g.cs
index ef58d99b..fce35976 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/Invoker/Find/Iterator/T14.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/Invoker/Find/Iterator/T14.g.cs
@@ -1,5 +1,7 @@
 // Find/Iterator/T14.g.cs
 // File was auto-generated by /_/src/Flecs.NET.Codegen/Generators/Invoker.cs
+using System;
+using System.Runtime.CompilerServices;
 using Flecs.NET.Utilities;
 using static Flecs.NET.Bindings.flecs;
 
@@ -17,25 +19,135 @@ public static Entity Find<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8); byte* pointer9 = (byte*)it.GetPointer<T9>(9); byte* pointer10 = (byte*)it.GetPointer<T10>(10); byte* pointer11 = (byte*)it.GetPointer<T11>(11); byte* pointer12 = (byte*)it.GetPointer<T12>(12); byte* pointer13 = (byte*)it.GetPointer<T13>(13);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8); int step9 = it.Step<T9>(9); int step10 = it.Step<T10>(10); int step11 = it.Step<T11>(11); int step12 = it.Step<T12>(12); int step13 = it.Step<T13>(13);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8); FieldData<T9> field9 = it.GetFieldData<T9>(9); FieldData<T10> field10 = it.GetFieldData<T10>(10); FieldData<T11> field11 = it.GetFieldData<T11>(11); FieldData<T12> field12 = it.GetFieldData<T12>(12); FieldData<T13> field13 = it.GetFieldData<T13>(13);
+        IterationTechnique flags = it.GetIterationTechnique(14);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8], pointer9 = &pointer9[step9], pointer10 = &pointer10[step10], pointer11 = &pointer11[step11], pointer12 = &pointer12[step12], pointer13 = &pointer13[step13])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>() || RuntimeHelpers.IsReferenceOrContainsReferences<T9>() || RuntimeHelpers.IsReferenceOrContainsReferences<T10>() || RuntimeHelpers.IsReferenceOrContainsReferences<T11>() || RuntimeHelpers.IsReferenceOrContainsReferences<T12>() || RuntimeHelpers.IsReferenceOrContainsReferences<T13>())
         {
-            if (!callback(ref Managed.GetTypeRef<T0>(pointer0), ref Managed.GetTypeRef<T1>(pointer1), ref Managed.GetTypeRef<T2>(pointer2), ref Managed.GetTypeRef<T3>(pointer3), ref Managed.GetTypeRef<T4>(pointer4), ref Managed.GetTypeRef<T5>(pointer5), ref Managed.GetTypeRef<T6>(pointer6), ref Managed.GetTypeRef<T7>(pointer7), ref Managed.GetTypeRef<T8>(pointer8), ref Managed.GetTypeRef<T9>(pointer9), ref Managed.GetTypeRef<T10>(pointer10), ref Managed.GetTypeRef<T11>(pointer11), ref Managed.GetTypeRef<T12>(pointer12), ref Managed.GetTypeRef<T13>(pointer13)))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, Ecs.FindRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefUnmanaged(i), ref field1.RefUnmanaged(i), ref field2.RefUnmanaged(i), ref field3.RefUnmanaged(i), ref field4.RefUnmanaged(i), ref field5.RefUnmanaged(i), ref field6.RefUnmanaged(i), ref field7.RefUnmanaged(i), ref field8.RefUnmanaged(i), ref field9.RefUnmanaged(i), ref field10.RefUnmanaged(i), ref field11.RefUnmanaged(i), ref field12.RefUnmanaged(i), ref field13.RefUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, Ecs.FindRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSharedUnmanaged(i), ref field1.RefSharedUnmanaged(i), ref field2.RefSharedUnmanaged(i), ref field3.RefSharedUnmanaged(i), ref field4.RefSharedUnmanaged(i), ref field5.RefSharedUnmanaged(i), ref field6.RefSharedUnmanaged(i), ref field7.RefSharedUnmanaged(i), ref field8.RefSharedUnmanaged(i), ref field9.RefSharedUnmanaged(i), ref field10.RefSharedUnmanaged(i), ref field11.RefSharedUnmanaged(i), ref field12.RefSharedUnmanaged(i), ref field13.RefSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, Ecs.FindRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSparseUnmanaged(i), ref field1.RefSparseUnmanaged(i), ref field2.RefSparseUnmanaged(i), ref field3.RefSparseUnmanaged(i), ref field4.RefSparseUnmanaged(i), ref field5.RefSparseUnmanaged(i), ref field6.RefSparseUnmanaged(i), ref field7.RefSparseUnmanaged(i), ref field8.RefSparseUnmanaged(i), ref field9.RefSparseUnmanaged(i), ref field10.RefSparseUnmanaged(i), ref field11.RefSparseUnmanaged(i), ref field12.RefSparseUnmanaged(i), ref field13.RefSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, Ecs.FindRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSparseSharedUnmanaged(i), ref field1.RefSparseSharedUnmanaged(i), ref field2.RefSparseSharedUnmanaged(i), ref field3.RefSparseSharedUnmanaged(i), ref field4.RefSparseSharedUnmanaged(i), ref field5.RefSparseSharedUnmanaged(i), ref field6.RefSparseSharedUnmanaged(i), ref field7.RefSparseSharedUnmanaged(i), ref field8.RefSparseSharedUnmanaged(i), ref field9.RefSparseSharedUnmanaged(i), ref field10.RefSparseSharedUnmanaged(i), ref field11.RefSparseSharedUnmanaged(i), ref field12.RefSparseSharedUnmanaged(i), ref field13.RefSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, Ecs.FindRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefManaged(i), ref field1.RefManaged(i), ref field2.RefManaged(i), ref field3.RefManaged(i), ref field4.RefManaged(i), ref field5.RefManaged(i), ref field6.RefManaged(i), ref field7.RefManaged(i), ref field8.RefManaged(i), ref field9.RefManaged(i), ref field10.RefManaged(i), ref field11.RefManaged(i), ref field12.RefManaged(i), ref field13.RefManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, Ecs.FindRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSharedManaged(i), ref field1.RefSharedManaged(i), ref field2.RefSharedManaged(i), ref field3.RefSharedManaged(i), ref field4.RefSharedManaged(i), ref field5.RefSharedManaged(i), ref field6.RefSharedManaged(i), ref field7.RefSharedManaged(i), ref field8.RefSharedManaged(i), ref field9.RefSharedManaged(i), ref field10.RefSharedManaged(i), ref field11.RefSharedManaged(i), ref field12.RefSharedManaged(i), ref field13.RefSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, Ecs.FindRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSparseManaged(i), ref field1.RefSparseManaged(i), ref field2.RefSparseManaged(i), ref field3.RefSparseManaged(i), ref field4.RefSparseManaged(i), ref field5.RefSparseManaged(i), ref field6.RefSparseManaged(i), ref field7.RefSparseManaged(i), ref field8.RefSparseManaged(i), ref field9.RefSparseManaged(i), ref field10.RefSparseManaged(i), ref field11.RefSparseManaged(i), ref field12.RefSparseManaged(i), ref field13.RefSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, Ecs.FindRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSparseSharedManaged(i), ref field1.RefSparseSharedManaged(i), ref field2.RefSparseSharedManaged(i), ref field3.RefSparseSharedManaged(i), ref field4.RefSparseSharedManaged(i), ref field5.RefSparseSharedManaged(i), ref field6.RefSparseSharedManaged(i), ref field7.RefSparseSharedManaged(i), ref field8.RefSparseSharedManaged(i), ref field9.RefSparseSharedManaged(i), ref field10.RefSparseSharedManaged(i), ref field11.RefSparseSharedManaged(i), ref field12.RefSparseSharedManaged(i), ref field13.RefSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 
     /// <summary>
@@ -48,25 +160,135 @@ public static Entity Find<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
     {
         int count = it.Handle->count; Ecs.Assert(it.Handle->count > 0, "No entities returned, use Iter() or Each() without the entity argument instead.");
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8); byte* pointer9 = (byte*)it.GetPointer<T9>(9); byte* pointer10 = (byte*)it.GetPointer<T10>(10); byte* pointer11 = (byte*)it.GetPointer<T11>(11); byte* pointer12 = (byte*)it.GetPointer<T12>(12); byte* pointer13 = (byte*)it.GetPointer<T13>(13);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8); int step9 = it.Step<T9>(9); int step10 = it.Step<T10>(10); int step11 = it.Step<T11>(11); int step12 = it.Step<T12>(12); int step13 = it.Step<T13>(13);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8); FieldData<T9> field9 = it.GetFieldData<T9>(9); FieldData<T10> field10 = it.GetFieldData<T10>(10); FieldData<T11> field11 = it.GetFieldData<T11>(11); FieldData<T12> field12 = it.GetFieldData<T12>(12); FieldData<T13> field13 = it.GetFieldData<T13>(13);
+        IterationTechnique flags = it.GetIterationTechnique(14);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8], pointer9 = &pointer9[step9], pointer10 = &pointer10[step10], pointer11 = &pointer11[step11], pointer12 = &pointer12[step12], pointer13 = &pointer13[step13])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>() || RuntimeHelpers.IsReferenceOrContainsReferences<T9>() || RuntimeHelpers.IsReferenceOrContainsReferences<T10>() || RuntimeHelpers.IsReferenceOrContainsReferences<T11>() || RuntimeHelpers.IsReferenceOrContainsReferences<T12>() || RuntimeHelpers.IsReferenceOrContainsReferences<T13>())
         {
-            if (!callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref Managed.GetTypeRef<T0>(pointer0), ref Managed.GetTypeRef<T1>(pointer1), ref Managed.GetTypeRef<T2>(pointer2), ref Managed.GetTypeRef<T3>(pointer3), ref Managed.GetTypeRef<T4>(pointer4), ref Managed.GetTypeRef<T5>(pointer5), ref Managed.GetTypeRef<T6>(pointer6), ref Managed.GetTypeRef<T7>(pointer7), ref Managed.GetTypeRef<T8>(pointer8), ref Managed.GetTypeRef<T9>(pointer9), ref Managed.GetTypeRef<T10>(pointer10), ref Managed.GetTypeRef<T11>(pointer11), ref Managed.GetTypeRef<T12>(pointer12), ref Managed.GetTypeRef<T13>(pointer13)))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefUnmanaged(i), ref field1.RefUnmanaged(i), ref field2.RefUnmanaged(i), ref field3.RefUnmanaged(i), ref field4.RefUnmanaged(i), ref field5.RefUnmanaged(i), ref field6.RefUnmanaged(i), ref field7.RefUnmanaged(i), ref field8.RefUnmanaged(i), ref field9.RefUnmanaged(i), ref field10.RefUnmanaged(i), ref field11.RefUnmanaged(i), ref field12.RefUnmanaged(i), ref field13.RefUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSharedUnmanaged(i), ref field1.RefSharedUnmanaged(i), ref field2.RefSharedUnmanaged(i), ref field3.RefSharedUnmanaged(i), ref field4.RefSharedUnmanaged(i), ref field5.RefSharedUnmanaged(i), ref field6.RefSharedUnmanaged(i), ref field7.RefSharedUnmanaged(i), ref field8.RefSharedUnmanaged(i), ref field9.RefSharedUnmanaged(i), ref field10.RefSharedUnmanaged(i), ref field11.RefSharedUnmanaged(i), ref field12.RefSharedUnmanaged(i), ref field13.RefSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseUnmanaged(i), ref field1.RefSparseUnmanaged(i), ref field2.RefSparseUnmanaged(i), ref field3.RefSparseUnmanaged(i), ref field4.RefSparseUnmanaged(i), ref field5.RefSparseUnmanaged(i), ref field6.RefSparseUnmanaged(i), ref field7.RefSparseUnmanaged(i), ref field8.RefSparseUnmanaged(i), ref field9.RefSparseUnmanaged(i), ref field10.RefSparseUnmanaged(i), ref field11.RefSparseUnmanaged(i), ref field12.RefSparseUnmanaged(i), ref field13.RefSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseSharedUnmanaged(i), ref field1.RefSparseSharedUnmanaged(i), ref field2.RefSparseSharedUnmanaged(i), ref field3.RefSparseSharedUnmanaged(i), ref field4.RefSparseSharedUnmanaged(i), ref field5.RefSparseSharedUnmanaged(i), ref field6.RefSparseSharedUnmanaged(i), ref field7.RefSparseSharedUnmanaged(i), ref field8.RefSparseSharedUnmanaged(i), ref field9.RefSparseSharedUnmanaged(i), ref field10.RefSparseSharedUnmanaged(i), ref field11.RefSparseSharedUnmanaged(i), ref field12.RefSparseSharedUnmanaged(i), ref field13.RefSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefManaged(i), ref field1.RefManaged(i), ref field2.RefManaged(i), ref field3.RefManaged(i), ref field4.RefManaged(i), ref field5.RefManaged(i), ref field6.RefManaged(i), ref field7.RefManaged(i), ref field8.RefManaged(i), ref field9.RefManaged(i), ref field10.RefManaged(i), ref field11.RefManaged(i), ref field12.RefManaged(i), ref field13.RefManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSharedManaged(i), ref field1.RefSharedManaged(i), ref field2.RefSharedManaged(i), ref field3.RefSharedManaged(i), ref field4.RefSharedManaged(i), ref field5.RefSharedManaged(i), ref field6.RefSharedManaged(i), ref field7.RefSharedManaged(i), ref field8.RefSharedManaged(i), ref field9.RefSharedManaged(i), ref field10.RefSharedManaged(i), ref field11.RefSharedManaged(i), ref field12.RefSharedManaged(i), ref field13.RefSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseManaged(i), ref field1.RefSparseManaged(i), ref field2.RefSparseManaged(i), ref field3.RefSparseManaged(i), ref field4.RefSparseManaged(i), ref field5.RefSparseManaged(i), ref field6.RefSparseManaged(i), ref field7.RefSparseManaged(i), ref field8.RefSparseManaged(i), ref field9.RefSparseManaged(i), ref field10.RefSparseManaged(i), ref field11.RefSparseManaged(i), ref field12.RefSparseManaged(i), ref field13.RefSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseSharedManaged(i), ref field1.RefSparseSharedManaged(i), ref field2.RefSparseSharedManaged(i), ref field3.RefSparseSharedManaged(i), ref field4.RefSparseSharedManaged(i), ref field5.RefSparseSharedManaged(i), ref field6.RefSparseSharedManaged(i), ref field7.RefSparseSharedManaged(i), ref field8.RefSparseSharedManaged(i), ref field9.RefSparseSharedManaged(i), ref field10.RefSparseSharedManaged(i), ref field11.RefSparseSharedManaged(i), ref field12.RefSparseSharedManaged(i), ref field13.RefSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 
     /// <summary>
@@ -79,25 +301,135 @@ public static Entity Find<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8); byte* pointer9 = (byte*)it.GetPointer<T9>(9); byte* pointer10 = (byte*)it.GetPointer<T10>(10); byte* pointer11 = (byte*)it.GetPointer<T11>(11); byte* pointer12 = (byte*)it.GetPointer<T12>(12); byte* pointer13 = (byte*)it.GetPointer<T13>(13);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8); int step9 = it.Step<T9>(9); int step10 = it.Step<T10>(10); int step11 = it.Step<T11>(11); int step12 = it.Step<T12>(12); int step13 = it.Step<T13>(13);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8); FieldData<T9> field9 = it.GetFieldData<T9>(9); FieldData<T10> field10 = it.GetFieldData<T10>(10); FieldData<T11> field11 = it.GetFieldData<T11>(11); FieldData<T12> field12 = it.GetFieldData<T12>(12); FieldData<T13> field13 = it.GetFieldData<T13>(13);
+        IterationTechnique flags = it.GetIterationTechnique(14);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8], pointer9 = &pointer9[step9], pointer10 = &pointer10[step10], pointer11 = &pointer11[step11], pointer12 = &pointer12[step12], pointer13 = &pointer13[step13])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>() || RuntimeHelpers.IsReferenceOrContainsReferences<T9>() || RuntimeHelpers.IsReferenceOrContainsReferences<T10>() || RuntimeHelpers.IsReferenceOrContainsReferences<T11>() || RuntimeHelpers.IsReferenceOrContainsReferences<T12>() || RuntimeHelpers.IsReferenceOrContainsReferences<T13>())
         {
-            if (!callback(it, i, ref Managed.GetTypeRef<T0>(pointer0), ref Managed.GetTypeRef<T1>(pointer1), ref Managed.GetTypeRef<T2>(pointer2), ref Managed.GetTypeRef<T3>(pointer3), ref Managed.GetTypeRef<T4>(pointer4), ref Managed.GetTypeRef<T5>(pointer5), ref Managed.GetTypeRef<T6>(pointer6), ref Managed.GetTypeRef<T7>(pointer7), ref Managed.GetTypeRef<T8>(pointer8), ref Managed.GetTypeRef<T9>(pointer9), ref Managed.GetTypeRef<T10>(pointer10), ref Managed.GetTypeRef<T11>(pointer11), ref Managed.GetTypeRef<T12>(pointer12), ref Managed.GetTypeRef<T13>(pointer13)))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, Ecs.FindIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefUnmanaged(i), ref field1.RefUnmanaged(i), ref field2.RefUnmanaged(i), ref field3.RefUnmanaged(i), ref field4.RefUnmanaged(i), ref field5.RefUnmanaged(i), ref field6.RefUnmanaged(i), ref field7.RefUnmanaged(i), ref field8.RefUnmanaged(i), ref field9.RefUnmanaged(i), ref field10.RefUnmanaged(i), ref field11.RefUnmanaged(i), ref field12.RefUnmanaged(i), ref field13.RefUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, Ecs.FindIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSharedUnmanaged(i), ref field1.RefSharedUnmanaged(i), ref field2.RefSharedUnmanaged(i), ref field3.RefSharedUnmanaged(i), ref field4.RefSharedUnmanaged(i), ref field5.RefSharedUnmanaged(i), ref field6.RefSharedUnmanaged(i), ref field7.RefSharedUnmanaged(i), ref field8.RefSharedUnmanaged(i), ref field9.RefSharedUnmanaged(i), ref field10.RefSharedUnmanaged(i), ref field11.RefSharedUnmanaged(i), ref field12.RefSharedUnmanaged(i), ref field13.RefSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, Ecs.FindIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSparseUnmanaged(i), ref field1.RefSparseUnmanaged(i), ref field2.RefSparseUnmanaged(i), ref field3.RefSparseUnmanaged(i), ref field4.RefSparseUnmanaged(i), ref field5.RefSparseUnmanaged(i), ref field6.RefSparseUnmanaged(i), ref field7.RefSparseUnmanaged(i), ref field8.RefSparseUnmanaged(i), ref field9.RefSparseUnmanaged(i), ref field10.RefSparseUnmanaged(i), ref field11.RefSparseUnmanaged(i), ref field12.RefSparseUnmanaged(i), ref field13.RefSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, Ecs.FindIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSparseSharedUnmanaged(i), ref field1.RefSparseSharedUnmanaged(i), ref field2.RefSparseSharedUnmanaged(i), ref field3.RefSparseSharedUnmanaged(i), ref field4.RefSparseSharedUnmanaged(i), ref field5.RefSparseSharedUnmanaged(i), ref field6.RefSparseSharedUnmanaged(i), ref field7.RefSparseSharedUnmanaged(i), ref field8.RefSparseSharedUnmanaged(i), ref field9.RefSparseSharedUnmanaged(i), ref field10.RefSparseSharedUnmanaged(i), ref field11.RefSparseSharedUnmanaged(i), ref field12.RefSparseSharedUnmanaged(i), ref field13.RefSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, Ecs.FindIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefManaged(i), ref field1.RefManaged(i), ref field2.RefManaged(i), ref field3.RefManaged(i), ref field4.RefManaged(i), ref field5.RefManaged(i), ref field6.RefManaged(i), ref field7.RefManaged(i), ref field8.RefManaged(i), ref field9.RefManaged(i), ref field10.RefManaged(i), ref field11.RefManaged(i), ref field12.RefManaged(i), ref field13.RefManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, Ecs.FindIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSharedManaged(i), ref field1.RefSharedManaged(i), ref field2.RefSharedManaged(i), ref field3.RefSharedManaged(i), ref field4.RefSharedManaged(i), ref field5.RefSharedManaged(i), ref field6.RefSharedManaged(i), ref field7.RefSharedManaged(i), ref field8.RefSharedManaged(i), ref field9.RefSharedManaged(i), ref field10.RefSharedManaged(i), ref field11.RefSharedManaged(i), ref field12.RefSharedManaged(i), ref field13.RefSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, Ecs.FindIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSparseManaged(i), ref field1.RefSparseManaged(i), ref field2.RefSparseManaged(i), ref field3.RefSparseManaged(i), ref field4.RefSparseManaged(i), ref field5.RefSparseManaged(i), ref field6.RefSparseManaged(i), ref field7.RefSparseManaged(i), ref field8.RefSparseManaged(i), ref field9.RefSparseManaged(i), ref field10.RefSparseManaged(i), ref field11.RefSparseManaged(i), ref field12.RefSparseManaged(i), ref field13.RefSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, Ecs.FindIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSparseSharedManaged(i), ref field1.RefSparseSharedManaged(i), ref field2.RefSparseSharedManaged(i), ref field3.RefSparseSharedManaged(i), ref field4.RefSparseSharedManaged(i), ref field5.RefSparseSharedManaged(i), ref field6.RefSparseSharedManaged(i), ref field7.RefSparseSharedManaged(i), ref field8.RefSparseSharedManaged(i), ref field9.RefSparseSharedManaged(i), ref field10.RefSparseSharedManaged(i), ref field11.RefSparseSharedManaged(i), ref field12.RefSparseSharedManaged(i), ref field13.RefSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 
     /// <summary>
@@ -110,25 +442,135 @@ public static Entity Find<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8); byte* pointer9 = (byte*)it.GetPointer<T9>(9); byte* pointer10 = (byte*)it.GetPointer<T10>(10); byte* pointer11 = (byte*)it.GetPointer<T11>(11); byte* pointer12 = (byte*)it.GetPointer<T12>(12); byte* pointer13 = (byte*)it.GetPointer<T13>(13);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8); int step9 = it.Step<T9>(9); int step10 = it.Step<T10>(10); int step11 = it.Step<T11>(11); int step12 = it.Step<T12>(12); int step13 = it.Step<T13>(13);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8); FieldData<T9> field9 = it.GetFieldData<T9>(9); FieldData<T10> field10 = it.GetFieldData<T10>(10); FieldData<T11> field11 = it.GetFieldData<T11>(11); FieldData<T12> field12 = it.GetFieldData<T12>(12); FieldData<T13> field13 = it.GetFieldData<T13>(13);
+        IterationTechnique flags = it.GetIterationTechnique(14);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8], pointer9 = &pointer9[step9], pointer10 = &pointer10[step10], pointer11 = &pointer11[step11], pointer12 = &pointer12[step12], pointer13 = &pointer13[step13])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>() || RuntimeHelpers.IsReferenceOrContainsReferences<T9>() || RuntimeHelpers.IsReferenceOrContainsReferences<T10>() || RuntimeHelpers.IsReferenceOrContainsReferences<T11>() || RuntimeHelpers.IsReferenceOrContainsReferences<T12>() || RuntimeHelpers.IsReferenceOrContainsReferences<T13>())
         {
-            if (!callback(ref Managed.GetTypeRef<T0>(pointer0), ref Managed.GetTypeRef<T1>(pointer1), ref Managed.GetTypeRef<T2>(pointer2), ref Managed.GetTypeRef<T3>(pointer3), ref Managed.GetTypeRef<T4>(pointer4), ref Managed.GetTypeRef<T5>(pointer5), ref Managed.GetTypeRef<T6>(pointer6), ref Managed.GetTypeRef<T7>(pointer7), ref Managed.GetTypeRef<T8>(pointer8), ref Managed.GetTypeRef<T9>(pointer9), ref Managed.GetTypeRef<T10>(pointer10), ref Managed.GetTypeRef<T11>(pointer11), ref Managed.GetTypeRef<T12>(pointer12), ref Managed.GetTypeRef<T13>(pointer13)))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefUnmanaged(i), ref field1.RefUnmanaged(i), ref field2.RefUnmanaged(i), ref field3.RefUnmanaged(i), ref field4.RefUnmanaged(i), ref field5.RefUnmanaged(i), ref field6.RefUnmanaged(i), ref field7.RefUnmanaged(i), ref field8.RefUnmanaged(i), ref field9.RefUnmanaged(i), ref field10.RefUnmanaged(i), ref field11.RefUnmanaged(i), ref field12.RefUnmanaged(i), ref field13.RefUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSharedUnmanaged(i), ref field1.RefSharedUnmanaged(i), ref field2.RefSharedUnmanaged(i), ref field3.RefSharedUnmanaged(i), ref field4.RefSharedUnmanaged(i), ref field5.RefSharedUnmanaged(i), ref field6.RefSharedUnmanaged(i), ref field7.RefSharedUnmanaged(i), ref field8.RefSharedUnmanaged(i), ref field9.RefSharedUnmanaged(i), ref field10.RefSharedUnmanaged(i), ref field11.RefSharedUnmanaged(i), ref field12.RefSharedUnmanaged(i), ref field13.RefSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSparseUnmanaged(i), ref field1.RefSparseUnmanaged(i), ref field2.RefSparseUnmanaged(i), ref field3.RefSparseUnmanaged(i), ref field4.RefSparseUnmanaged(i), ref field5.RefSparseUnmanaged(i), ref field6.RefSparseUnmanaged(i), ref field7.RefSparseUnmanaged(i), ref field8.RefSparseUnmanaged(i), ref field9.RefSparseUnmanaged(i), ref field10.RefSparseUnmanaged(i), ref field11.RefSparseUnmanaged(i), ref field12.RefSparseUnmanaged(i), ref field13.RefSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSparseSharedUnmanaged(i), ref field1.RefSparseSharedUnmanaged(i), ref field2.RefSparseSharedUnmanaged(i), ref field3.RefSparseSharedUnmanaged(i), ref field4.RefSparseSharedUnmanaged(i), ref field5.RefSparseSharedUnmanaged(i), ref field6.RefSparseSharedUnmanaged(i), ref field7.RefSparseSharedUnmanaged(i), ref field8.RefSparseSharedUnmanaged(i), ref field9.RefSparseSharedUnmanaged(i), ref field10.RefSparseSharedUnmanaged(i), ref field11.RefSparseSharedUnmanaged(i), ref field12.RefSparseSharedUnmanaged(i), ref field13.RefSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefManaged(i), ref field1.RefManaged(i), ref field2.RefManaged(i), ref field3.RefManaged(i), ref field4.RefManaged(i), ref field5.RefManaged(i), ref field6.RefManaged(i), ref field7.RefManaged(i), ref field8.RefManaged(i), ref field9.RefManaged(i), ref field10.RefManaged(i), ref field11.RefManaged(i), ref field12.RefManaged(i), ref field13.RefManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSharedManaged(i), ref field1.RefSharedManaged(i), ref field2.RefSharedManaged(i), ref field3.RefSharedManaged(i), ref field4.RefSharedManaged(i), ref field5.RefSharedManaged(i), ref field6.RefSharedManaged(i), ref field7.RefSharedManaged(i), ref field8.RefSharedManaged(i), ref field9.RefSharedManaged(i), ref field10.RefSharedManaged(i), ref field11.RefSharedManaged(i), ref field12.RefSharedManaged(i), ref field13.RefSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSparseManaged(i), ref field1.RefSparseManaged(i), ref field2.RefSparseManaged(i), ref field3.RefSparseManaged(i), ref field4.RefSparseManaged(i), ref field5.RefSparseManaged(i), ref field6.RefSparseManaged(i), ref field7.RefSparseManaged(i), ref field8.RefSparseManaged(i), ref field9.RefSparseManaged(i), ref field10.RefSparseManaged(i), ref field11.RefSparseManaged(i), ref field12.RefSparseManaged(i), ref field13.RefSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSparseSharedManaged(i), ref field1.RefSparseSharedManaged(i), ref field2.RefSparseSharedManaged(i), ref field3.RefSparseSharedManaged(i), ref field4.RefSparseSharedManaged(i), ref field5.RefSparseSharedManaged(i), ref field6.RefSparseSharedManaged(i), ref field7.RefSparseSharedManaged(i), ref field8.RefSparseSharedManaged(i), ref field9.RefSparseSharedManaged(i), ref field10.RefSparseSharedManaged(i), ref field11.RefSparseSharedManaged(i), ref field12.RefSparseSharedManaged(i), ref field13.RefSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 
     /// <summary>
@@ -141,25 +583,135 @@ public static Entity Find<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
     {
         int count = it.Handle->count; Ecs.Assert(it.Handle->count > 0, "No entities returned, use Iter() or Each() without the entity argument instead.");
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8); byte* pointer9 = (byte*)it.GetPointer<T9>(9); byte* pointer10 = (byte*)it.GetPointer<T10>(10); byte* pointer11 = (byte*)it.GetPointer<T11>(11); byte* pointer12 = (byte*)it.GetPointer<T12>(12); byte* pointer13 = (byte*)it.GetPointer<T13>(13);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8); int step9 = it.Step<T9>(9); int step10 = it.Step<T10>(10); int step11 = it.Step<T11>(11); int step12 = it.Step<T12>(12); int step13 = it.Step<T13>(13);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8); FieldData<T9> field9 = it.GetFieldData<T9>(9); FieldData<T10> field10 = it.GetFieldData<T10>(10); FieldData<T11> field11 = it.GetFieldData<T11>(11); FieldData<T12> field12 = it.GetFieldData<T12>(12); FieldData<T13> field13 = it.GetFieldData<T13>(13);
+        IterationTechnique flags = it.GetIterationTechnique(14);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8], pointer9 = &pointer9[step9], pointer10 = &pointer10[step10], pointer11 = &pointer11[step11], pointer12 = &pointer12[step12], pointer13 = &pointer13[step13])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>() || RuntimeHelpers.IsReferenceOrContainsReferences<T9>() || RuntimeHelpers.IsReferenceOrContainsReferences<T10>() || RuntimeHelpers.IsReferenceOrContainsReferences<T11>() || RuntimeHelpers.IsReferenceOrContainsReferences<T12>() || RuntimeHelpers.IsReferenceOrContainsReferences<T13>())
         {
-            if (!callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref Managed.GetTypeRef<T0>(pointer0), ref Managed.GetTypeRef<T1>(pointer1), ref Managed.GetTypeRef<T2>(pointer2), ref Managed.GetTypeRef<T3>(pointer3), ref Managed.GetTypeRef<T4>(pointer4), ref Managed.GetTypeRef<T5>(pointer5), ref Managed.GetTypeRef<T6>(pointer6), ref Managed.GetTypeRef<T7>(pointer7), ref Managed.GetTypeRef<T8>(pointer8), ref Managed.GetTypeRef<T9>(pointer9), ref Managed.GetTypeRef<T10>(pointer10), ref Managed.GetTypeRef<T11>(pointer11), ref Managed.GetTypeRef<T12>(pointer12), ref Managed.GetTypeRef<T13>(pointer13)))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefUnmanaged(i), ref field1.RefUnmanaged(i), ref field2.RefUnmanaged(i), ref field3.RefUnmanaged(i), ref field4.RefUnmanaged(i), ref field5.RefUnmanaged(i), ref field6.RefUnmanaged(i), ref field7.RefUnmanaged(i), ref field8.RefUnmanaged(i), ref field9.RefUnmanaged(i), ref field10.RefUnmanaged(i), ref field11.RefUnmanaged(i), ref field12.RefUnmanaged(i), ref field13.RefUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSharedUnmanaged(i), ref field1.RefSharedUnmanaged(i), ref field2.RefSharedUnmanaged(i), ref field3.RefSharedUnmanaged(i), ref field4.RefSharedUnmanaged(i), ref field5.RefSharedUnmanaged(i), ref field6.RefSharedUnmanaged(i), ref field7.RefSharedUnmanaged(i), ref field8.RefSharedUnmanaged(i), ref field9.RefSharedUnmanaged(i), ref field10.RefSharedUnmanaged(i), ref field11.RefSharedUnmanaged(i), ref field12.RefSharedUnmanaged(i), ref field13.RefSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseUnmanaged(i), ref field1.RefSparseUnmanaged(i), ref field2.RefSparseUnmanaged(i), ref field3.RefSparseUnmanaged(i), ref field4.RefSparseUnmanaged(i), ref field5.RefSparseUnmanaged(i), ref field6.RefSparseUnmanaged(i), ref field7.RefSparseUnmanaged(i), ref field8.RefSparseUnmanaged(i), ref field9.RefSparseUnmanaged(i), ref field10.RefSparseUnmanaged(i), ref field11.RefSparseUnmanaged(i), ref field12.RefSparseUnmanaged(i), ref field13.RefSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseSharedUnmanaged(i), ref field1.RefSparseSharedUnmanaged(i), ref field2.RefSparseSharedUnmanaged(i), ref field3.RefSparseSharedUnmanaged(i), ref field4.RefSparseSharedUnmanaged(i), ref field5.RefSparseSharedUnmanaged(i), ref field6.RefSparseSharedUnmanaged(i), ref field7.RefSparseSharedUnmanaged(i), ref field8.RefSparseSharedUnmanaged(i), ref field9.RefSparseSharedUnmanaged(i), ref field10.RefSparseSharedUnmanaged(i), ref field11.RefSparseSharedUnmanaged(i), ref field12.RefSparseSharedUnmanaged(i), ref field13.RefSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefManaged(i), ref field1.RefManaged(i), ref field2.RefManaged(i), ref field3.RefManaged(i), ref field4.RefManaged(i), ref field5.RefManaged(i), ref field6.RefManaged(i), ref field7.RefManaged(i), ref field8.RefManaged(i), ref field9.RefManaged(i), ref field10.RefManaged(i), ref field11.RefManaged(i), ref field12.RefManaged(i), ref field13.RefManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSharedManaged(i), ref field1.RefSharedManaged(i), ref field2.RefSharedManaged(i), ref field3.RefSharedManaged(i), ref field4.RefSharedManaged(i), ref field5.RefSharedManaged(i), ref field6.RefSharedManaged(i), ref field7.RefSharedManaged(i), ref field8.RefSharedManaged(i), ref field9.RefSharedManaged(i), ref field10.RefSharedManaged(i), ref field11.RefSharedManaged(i), ref field12.RefSharedManaged(i), ref field13.RefSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseManaged(i), ref field1.RefSparseManaged(i), ref field2.RefSparseManaged(i), ref field3.RefSparseManaged(i), ref field4.RefSparseManaged(i), ref field5.RefSparseManaged(i), ref field6.RefSparseManaged(i), ref field7.RefSparseManaged(i), ref field8.RefSparseManaged(i), ref field9.RefSparseManaged(i), ref field10.RefSparseManaged(i), ref field11.RefSparseManaged(i), ref field12.RefSparseManaged(i), ref field13.RefSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseSharedManaged(i), ref field1.RefSparseSharedManaged(i), ref field2.RefSparseSharedManaged(i), ref field3.RefSparseSharedManaged(i), ref field4.RefSparseSharedManaged(i), ref field5.RefSparseSharedManaged(i), ref field6.RefSparseSharedManaged(i), ref field7.RefSparseSharedManaged(i), ref field8.RefSparseSharedManaged(i), ref field9.RefSparseSharedManaged(i), ref field10.RefSparseSharedManaged(i), ref field11.RefSparseSharedManaged(i), ref field12.RefSparseSharedManaged(i), ref field13.RefSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 
     /// <summary>
@@ -172,25 +724,135 @@ public static Entity Find<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8); byte* pointer9 = (byte*)it.GetPointer<T9>(9); byte* pointer10 = (byte*)it.GetPointer<T10>(10); byte* pointer11 = (byte*)it.GetPointer<T11>(11); byte* pointer12 = (byte*)it.GetPointer<T12>(12); byte* pointer13 = (byte*)it.GetPointer<T13>(13);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8); int step9 = it.Step<T9>(9); int step10 = it.Step<T10>(10); int step11 = it.Step<T11>(11); int step12 = it.Step<T12>(12); int step13 = it.Step<T13>(13);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8); FieldData<T9> field9 = it.GetFieldData<T9>(9); FieldData<T10> field10 = it.GetFieldData<T10>(10); FieldData<T11> field11 = it.GetFieldData<T11>(11); FieldData<T12> field12 = it.GetFieldData<T12>(12); FieldData<T13> field13 = it.GetFieldData<T13>(13);
+        IterationTechnique flags = it.GetIterationTechnique(14);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8], pointer9 = &pointer9[step9], pointer10 = &pointer10[step10], pointer11 = &pointer11[step11], pointer12 = &pointer12[step12], pointer13 = &pointer13[step13])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>() || RuntimeHelpers.IsReferenceOrContainsReferences<T9>() || RuntimeHelpers.IsReferenceOrContainsReferences<T10>() || RuntimeHelpers.IsReferenceOrContainsReferences<T11>() || RuntimeHelpers.IsReferenceOrContainsReferences<T12>() || RuntimeHelpers.IsReferenceOrContainsReferences<T13>())
         {
-            if (!callback(it, i, ref Managed.GetTypeRef<T0>(pointer0), ref Managed.GetTypeRef<T1>(pointer1), ref Managed.GetTypeRef<T2>(pointer2), ref Managed.GetTypeRef<T3>(pointer3), ref Managed.GetTypeRef<T4>(pointer4), ref Managed.GetTypeRef<T5>(pointer5), ref Managed.GetTypeRef<T6>(pointer6), ref Managed.GetTypeRef<T7>(pointer7), ref Managed.GetTypeRef<T8>(pointer8), ref Managed.GetTypeRef<T9>(pointer9), ref Managed.GetTypeRef<T10>(pointer10), ref Managed.GetTypeRef<T11>(pointer11), ref Managed.GetTypeRef<T12>(pointer12), ref Managed.GetTypeRef<T13>(pointer13)))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefUnmanaged(i), ref field1.RefUnmanaged(i), ref field2.RefUnmanaged(i), ref field3.RefUnmanaged(i), ref field4.RefUnmanaged(i), ref field5.RefUnmanaged(i), ref field6.RefUnmanaged(i), ref field7.RefUnmanaged(i), ref field8.RefUnmanaged(i), ref field9.RefUnmanaged(i), ref field10.RefUnmanaged(i), ref field11.RefUnmanaged(i), ref field12.RefUnmanaged(i), ref field13.RefUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSharedUnmanaged(i), ref field1.RefSharedUnmanaged(i), ref field2.RefSharedUnmanaged(i), ref field3.RefSharedUnmanaged(i), ref field4.RefSharedUnmanaged(i), ref field5.RefSharedUnmanaged(i), ref field6.RefSharedUnmanaged(i), ref field7.RefSharedUnmanaged(i), ref field8.RefSharedUnmanaged(i), ref field9.RefSharedUnmanaged(i), ref field10.RefSharedUnmanaged(i), ref field11.RefSharedUnmanaged(i), ref field12.RefSharedUnmanaged(i), ref field13.RefSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSparseUnmanaged(i), ref field1.RefSparseUnmanaged(i), ref field2.RefSparseUnmanaged(i), ref field3.RefSparseUnmanaged(i), ref field4.RefSparseUnmanaged(i), ref field5.RefSparseUnmanaged(i), ref field6.RefSparseUnmanaged(i), ref field7.RefSparseUnmanaged(i), ref field8.RefSparseUnmanaged(i), ref field9.RefSparseUnmanaged(i), ref field10.RefSparseUnmanaged(i), ref field11.RefSparseUnmanaged(i), ref field12.RefSparseUnmanaged(i), ref field13.RefSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSparseSharedUnmanaged(i), ref field1.RefSparseSharedUnmanaged(i), ref field2.RefSparseSharedUnmanaged(i), ref field3.RefSparseSharedUnmanaged(i), ref field4.RefSparseSharedUnmanaged(i), ref field5.RefSparseSharedUnmanaged(i), ref field6.RefSparseSharedUnmanaged(i), ref field7.RefSparseSharedUnmanaged(i), ref field8.RefSparseSharedUnmanaged(i), ref field9.RefSparseSharedUnmanaged(i), ref field10.RefSparseSharedUnmanaged(i), ref field11.RefSparseSharedUnmanaged(i), ref field12.RefSparseSharedUnmanaged(i), ref field13.RefSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefManaged(i), ref field1.RefManaged(i), ref field2.RefManaged(i), ref field3.RefManaged(i), ref field4.RefManaged(i), ref field5.RefManaged(i), ref field6.RefManaged(i), ref field7.RefManaged(i), ref field8.RefManaged(i), ref field9.RefManaged(i), ref field10.RefManaged(i), ref field11.RefManaged(i), ref field12.RefManaged(i), ref field13.RefManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSharedManaged(i), ref field1.RefSharedManaged(i), ref field2.RefSharedManaged(i), ref field3.RefSharedManaged(i), ref field4.RefSharedManaged(i), ref field5.RefSharedManaged(i), ref field6.RefSharedManaged(i), ref field7.RefSharedManaged(i), ref field8.RefSharedManaged(i), ref field9.RefSharedManaged(i), ref field10.RefSharedManaged(i), ref field11.RefSharedManaged(i), ref field12.RefSharedManaged(i), ref field13.RefSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSparseManaged(i), ref field1.RefSparseManaged(i), ref field2.RefSparseManaged(i), ref field3.RefSparseManaged(i), ref field4.RefSparseManaged(i), ref field5.RefSparseManaged(i), ref field6.RefSparseManaged(i), ref field7.RefSparseManaged(i), ref field8.RefSparseManaged(i), ref field9.RefSparseManaged(i), ref field10.RefSparseManaged(i), ref field11.RefSparseManaged(i), ref field12.RefSparseManaged(i), ref field13.RefSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSparseSharedManaged(i), ref field1.RefSparseSharedManaged(i), ref field2.RefSparseSharedManaged(i), ref field3.RefSparseSharedManaged(i), ref field4.RefSparseSharedManaged(i), ref field5.RefSparseSharedManaged(i), ref field6.RefSparseSharedManaged(i), ref field7.RefSparseSharedManaged(i), ref field8.RefSparseSharedManaged(i), ref field9.RefSparseSharedManaged(i), ref field10.RefSparseSharedManaged(i), ref field11.RefSparseSharedManaged(i), ref field12.RefSparseSharedManaged(i), ref field13.RefSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 
     /// <summary>
@@ -203,25 +865,135 @@ public static Entity Find<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8); byte* pointer9 = (byte*)it.GetPointer<T9>(9); byte* pointer10 = (byte*)it.GetPointer<T10>(10); byte* pointer11 = (byte*)it.GetPointer<T11>(11); byte* pointer12 = (byte*)it.GetPointer<T12>(12); byte* pointer13 = (byte*)it.GetPointer<T13>(13);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8); int step9 = it.Step<T9>(9); int step10 = it.Step<T10>(10); int step11 = it.Step<T11>(11); int step12 = it.Step<T12>(12); int step13 = it.Step<T13>(13);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8); FieldData<T9> field9 = it.GetFieldData<T9>(9); FieldData<T10> field10 = it.GetFieldData<T10>(10); FieldData<T11> field11 = it.GetFieldData<T11>(11); FieldData<T12> field12 = it.GetFieldData<T12>(12); FieldData<T13> field13 = it.GetFieldData<T13>(13);
+        IterationTechnique flags = it.GetIterationTechnique(14);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8], pointer9 = &pointer9[step9], pointer10 = &pointer10[step10], pointer11 = &pointer11[step11], pointer12 = &pointer12[step12], pointer13 = &pointer13[step13])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>() || RuntimeHelpers.IsReferenceOrContainsReferences<T9>() || RuntimeHelpers.IsReferenceOrContainsReferences<T10>() || RuntimeHelpers.IsReferenceOrContainsReferences<T11>() || RuntimeHelpers.IsReferenceOrContainsReferences<T12>() || RuntimeHelpers.IsReferenceOrContainsReferences<T13>())
         {
-            if (!callback((T0*)pointer0, (T1*)pointer1, (T2*)pointer2, (T3*)pointer3, (T4*)pointer4, (T5*)pointer5, (T6*)pointer6, (T7*)pointer7, (T8*)pointer8, (T9*)pointer9, (T10*)pointer10, (T11*)pointer11, (T12*)pointer12, (T13*)pointer13))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, Ecs.FindPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerUnmanaged(i), field1.PointerUnmanaged(i), field2.PointerUnmanaged(i), field3.PointerUnmanaged(i), field4.PointerUnmanaged(i), field5.PointerUnmanaged(i), field6.PointerUnmanaged(i), field7.PointerUnmanaged(i), field8.PointerUnmanaged(i), field9.PointerUnmanaged(i), field10.PointerUnmanaged(i), field11.PointerUnmanaged(i), field12.PointerUnmanaged(i), field13.PointerUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, Ecs.FindPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSharedUnmanaged(i), field1.PointerSharedUnmanaged(i), field2.PointerSharedUnmanaged(i), field3.PointerSharedUnmanaged(i), field4.PointerSharedUnmanaged(i), field5.PointerSharedUnmanaged(i), field6.PointerSharedUnmanaged(i), field7.PointerSharedUnmanaged(i), field8.PointerSharedUnmanaged(i), field9.PointerSharedUnmanaged(i), field10.PointerSharedUnmanaged(i), field11.PointerSharedUnmanaged(i), field12.PointerSharedUnmanaged(i), field13.PointerSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, Ecs.FindPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSparseUnmanaged(i), field1.PointerSparseUnmanaged(i), field2.PointerSparseUnmanaged(i), field3.PointerSparseUnmanaged(i), field4.PointerSparseUnmanaged(i), field5.PointerSparseUnmanaged(i), field6.PointerSparseUnmanaged(i), field7.PointerSparseUnmanaged(i), field8.PointerSparseUnmanaged(i), field9.PointerSparseUnmanaged(i), field10.PointerSparseUnmanaged(i), field11.PointerSparseUnmanaged(i), field12.PointerSparseUnmanaged(i), field13.PointerSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, Ecs.FindPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSparseSharedUnmanaged(i), field1.PointerSparseSharedUnmanaged(i), field2.PointerSparseSharedUnmanaged(i), field3.PointerSparseSharedUnmanaged(i), field4.PointerSparseSharedUnmanaged(i), field5.PointerSparseSharedUnmanaged(i), field6.PointerSparseSharedUnmanaged(i), field7.PointerSparseSharedUnmanaged(i), field8.PointerSparseSharedUnmanaged(i), field9.PointerSparseSharedUnmanaged(i), field10.PointerSparseSharedUnmanaged(i), field11.PointerSparseSharedUnmanaged(i), field12.PointerSparseSharedUnmanaged(i), field13.PointerSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, Ecs.FindPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerManaged(i), field1.PointerManaged(i), field2.PointerManaged(i), field3.PointerManaged(i), field4.PointerManaged(i), field5.PointerManaged(i), field6.PointerManaged(i), field7.PointerManaged(i), field8.PointerManaged(i), field9.PointerManaged(i), field10.PointerManaged(i), field11.PointerManaged(i), field12.PointerManaged(i), field13.PointerManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, Ecs.FindPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSharedManaged(i), field1.PointerSharedManaged(i), field2.PointerSharedManaged(i), field3.PointerSharedManaged(i), field4.PointerSharedManaged(i), field5.PointerSharedManaged(i), field6.PointerSharedManaged(i), field7.PointerSharedManaged(i), field8.PointerSharedManaged(i), field9.PointerSharedManaged(i), field10.PointerSharedManaged(i), field11.PointerSharedManaged(i), field12.PointerSharedManaged(i), field13.PointerSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, Ecs.FindPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSparseManaged(i), field1.PointerSparseManaged(i), field2.PointerSparseManaged(i), field3.PointerSparseManaged(i), field4.PointerSparseManaged(i), field5.PointerSparseManaged(i), field6.PointerSparseManaged(i), field7.PointerSparseManaged(i), field8.PointerSparseManaged(i), field9.PointerSparseManaged(i), field10.PointerSparseManaged(i), field11.PointerSparseManaged(i), field12.PointerSparseManaged(i), field13.PointerSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, Ecs.FindPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSparseSharedManaged(i), field1.PointerSparseSharedManaged(i), field2.PointerSparseSharedManaged(i), field3.PointerSparseSharedManaged(i), field4.PointerSparseSharedManaged(i), field5.PointerSparseSharedManaged(i), field6.PointerSparseSharedManaged(i), field7.PointerSparseSharedManaged(i), field8.PointerSparseSharedManaged(i), field9.PointerSparseSharedManaged(i), field10.PointerSparseSharedManaged(i), field11.PointerSparseSharedManaged(i), field12.PointerSparseSharedManaged(i), field13.PointerSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 
     /// <summary>
@@ -234,25 +1006,135 @@ public static Entity Find<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
     {
         int count = it.Handle->count; Ecs.Assert(it.Handle->count > 0, "No entities returned, use Iter() or Each() without the entity argument instead.");
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8); byte* pointer9 = (byte*)it.GetPointer<T9>(9); byte* pointer10 = (byte*)it.GetPointer<T10>(10); byte* pointer11 = (byte*)it.GetPointer<T11>(11); byte* pointer12 = (byte*)it.GetPointer<T12>(12); byte* pointer13 = (byte*)it.GetPointer<T13>(13);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8); int step9 = it.Step<T9>(9); int step10 = it.Step<T10>(10); int step11 = it.Step<T11>(11); int step12 = it.Step<T12>(12); int step13 = it.Step<T13>(13);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8); FieldData<T9> field9 = it.GetFieldData<T9>(9); FieldData<T10> field10 = it.GetFieldData<T10>(10); FieldData<T11> field11 = it.GetFieldData<T11>(11); FieldData<T12> field12 = it.GetFieldData<T12>(12); FieldData<T13> field13 = it.GetFieldData<T13>(13);
+        IterationTechnique flags = it.GetIterationTechnique(14);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8], pointer9 = &pointer9[step9], pointer10 = &pointer10[step10], pointer11 = &pointer11[step11], pointer12 = &pointer12[step12], pointer13 = &pointer13[step13])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>() || RuntimeHelpers.IsReferenceOrContainsReferences<T9>() || RuntimeHelpers.IsReferenceOrContainsReferences<T10>() || RuntimeHelpers.IsReferenceOrContainsReferences<T11>() || RuntimeHelpers.IsReferenceOrContainsReferences<T12>() || RuntimeHelpers.IsReferenceOrContainsReferences<T13>())
         {
-            if (!callback(new Entity(it.Handle->world, it.Handle->entities[i]), (T0*)pointer0, (T1*)pointer1, (T2*)pointer2, (T3*)pointer3, (T4*)pointer4, (T5*)pointer5, (T6*)pointer6, (T7*)pointer7, (T8*)pointer8, (T9*)pointer9, (T10*)pointer10, (T11*)pointer11, (T12*)pointer12, (T13*)pointer13))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerUnmanaged(i), field1.PointerUnmanaged(i), field2.PointerUnmanaged(i), field3.PointerUnmanaged(i), field4.PointerUnmanaged(i), field5.PointerUnmanaged(i), field6.PointerUnmanaged(i), field7.PointerUnmanaged(i), field8.PointerUnmanaged(i), field9.PointerUnmanaged(i), field10.PointerUnmanaged(i), field11.PointerUnmanaged(i), field12.PointerUnmanaged(i), field13.PointerUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSharedUnmanaged(i), field1.PointerSharedUnmanaged(i), field2.PointerSharedUnmanaged(i), field3.PointerSharedUnmanaged(i), field4.PointerSharedUnmanaged(i), field5.PointerSharedUnmanaged(i), field6.PointerSharedUnmanaged(i), field7.PointerSharedUnmanaged(i), field8.PointerSharedUnmanaged(i), field9.PointerSharedUnmanaged(i), field10.PointerSharedUnmanaged(i), field11.PointerSharedUnmanaged(i), field12.PointerSharedUnmanaged(i), field13.PointerSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseUnmanaged(i), field1.PointerSparseUnmanaged(i), field2.PointerSparseUnmanaged(i), field3.PointerSparseUnmanaged(i), field4.PointerSparseUnmanaged(i), field5.PointerSparseUnmanaged(i), field6.PointerSparseUnmanaged(i), field7.PointerSparseUnmanaged(i), field8.PointerSparseUnmanaged(i), field9.PointerSparseUnmanaged(i), field10.PointerSparseUnmanaged(i), field11.PointerSparseUnmanaged(i), field12.PointerSparseUnmanaged(i), field13.PointerSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseSharedUnmanaged(i), field1.PointerSparseSharedUnmanaged(i), field2.PointerSparseSharedUnmanaged(i), field3.PointerSparseSharedUnmanaged(i), field4.PointerSparseSharedUnmanaged(i), field5.PointerSparseSharedUnmanaged(i), field6.PointerSparseSharedUnmanaged(i), field7.PointerSparseSharedUnmanaged(i), field8.PointerSparseSharedUnmanaged(i), field9.PointerSparseSharedUnmanaged(i), field10.PointerSparseSharedUnmanaged(i), field11.PointerSparseSharedUnmanaged(i), field12.PointerSparseSharedUnmanaged(i), field13.PointerSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerManaged(i), field1.PointerManaged(i), field2.PointerManaged(i), field3.PointerManaged(i), field4.PointerManaged(i), field5.PointerManaged(i), field6.PointerManaged(i), field7.PointerManaged(i), field8.PointerManaged(i), field9.PointerManaged(i), field10.PointerManaged(i), field11.PointerManaged(i), field12.PointerManaged(i), field13.PointerManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSharedManaged(i), field1.PointerSharedManaged(i), field2.PointerSharedManaged(i), field3.PointerSharedManaged(i), field4.PointerSharedManaged(i), field5.PointerSharedManaged(i), field6.PointerSharedManaged(i), field7.PointerSharedManaged(i), field8.PointerSharedManaged(i), field9.PointerSharedManaged(i), field10.PointerSharedManaged(i), field11.PointerSharedManaged(i), field12.PointerSharedManaged(i), field13.PointerSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseManaged(i), field1.PointerSparseManaged(i), field2.PointerSparseManaged(i), field3.PointerSparseManaged(i), field4.PointerSparseManaged(i), field5.PointerSparseManaged(i), field6.PointerSparseManaged(i), field7.PointerSparseManaged(i), field8.PointerSparseManaged(i), field9.PointerSparseManaged(i), field10.PointerSparseManaged(i), field11.PointerSparseManaged(i), field12.PointerSparseManaged(i), field13.PointerSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseSharedManaged(i), field1.PointerSparseSharedManaged(i), field2.PointerSparseSharedManaged(i), field3.PointerSparseSharedManaged(i), field4.PointerSparseSharedManaged(i), field5.PointerSparseSharedManaged(i), field6.PointerSparseSharedManaged(i), field7.PointerSparseSharedManaged(i), field8.PointerSparseSharedManaged(i), field9.PointerSparseSharedManaged(i), field10.PointerSparseSharedManaged(i), field11.PointerSparseSharedManaged(i), field12.PointerSparseSharedManaged(i), field13.PointerSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 
     /// <summary>
@@ -265,25 +1147,135 @@ public static Entity Find<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8); byte* pointer9 = (byte*)it.GetPointer<T9>(9); byte* pointer10 = (byte*)it.GetPointer<T10>(10); byte* pointer11 = (byte*)it.GetPointer<T11>(11); byte* pointer12 = (byte*)it.GetPointer<T12>(12); byte* pointer13 = (byte*)it.GetPointer<T13>(13);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8); int step9 = it.Step<T9>(9); int step10 = it.Step<T10>(10); int step11 = it.Step<T11>(11); int step12 = it.Step<T12>(12); int step13 = it.Step<T13>(13);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8); FieldData<T9> field9 = it.GetFieldData<T9>(9); FieldData<T10> field10 = it.GetFieldData<T10>(10); FieldData<T11> field11 = it.GetFieldData<T11>(11); FieldData<T12> field12 = it.GetFieldData<T12>(12); FieldData<T13> field13 = it.GetFieldData<T13>(13);
+        IterationTechnique flags = it.GetIterationTechnique(14);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8], pointer9 = &pointer9[step9], pointer10 = &pointer10[step10], pointer11 = &pointer11[step11], pointer12 = &pointer12[step12], pointer13 = &pointer13[step13])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>() || RuntimeHelpers.IsReferenceOrContainsReferences<T9>() || RuntimeHelpers.IsReferenceOrContainsReferences<T10>() || RuntimeHelpers.IsReferenceOrContainsReferences<T11>() || RuntimeHelpers.IsReferenceOrContainsReferences<T12>() || RuntimeHelpers.IsReferenceOrContainsReferences<T13>())
         {
-            if (!callback(it, i, (T0*)pointer0, (T1*)pointer1, (T2*)pointer2, (T3*)pointer3, (T4*)pointer4, (T5*)pointer5, (T6*)pointer6, (T7*)pointer7, (T8*)pointer8, (T9*)pointer9, (T10*)pointer10, (T11*)pointer11, (T12*)pointer12, (T13*)pointer13))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerUnmanaged(i), field1.PointerUnmanaged(i), field2.PointerUnmanaged(i), field3.PointerUnmanaged(i), field4.PointerUnmanaged(i), field5.PointerUnmanaged(i), field6.PointerUnmanaged(i), field7.PointerUnmanaged(i), field8.PointerUnmanaged(i), field9.PointerUnmanaged(i), field10.PointerUnmanaged(i), field11.PointerUnmanaged(i), field12.PointerUnmanaged(i), field13.PointerUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSharedUnmanaged(i), field1.PointerSharedUnmanaged(i), field2.PointerSharedUnmanaged(i), field3.PointerSharedUnmanaged(i), field4.PointerSharedUnmanaged(i), field5.PointerSharedUnmanaged(i), field6.PointerSharedUnmanaged(i), field7.PointerSharedUnmanaged(i), field8.PointerSharedUnmanaged(i), field9.PointerSharedUnmanaged(i), field10.PointerSharedUnmanaged(i), field11.PointerSharedUnmanaged(i), field12.PointerSharedUnmanaged(i), field13.PointerSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSparseUnmanaged(i), field1.PointerSparseUnmanaged(i), field2.PointerSparseUnmanaged(i), field3.PointerSparseUnmanaged(i), field4.PointerSparseUnmanaged(i), field5.PointerSparseUnmanaged(i), field6.PointerSparseUnmanaged(i), field7.PointerSparseUnmanaged(i), field8.PointerSparseUnmanaged(i), field9.PointerSparseUnmanaged(i), field10.PointerSparseUnmanaged(i), field11.PointerSparseUnmanaged(i), field12.PointerSparseUnmanaged(i), field13.PointerSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSparseSharedUnmanaged(i), field1.PointerSparseSharedUnmanaged(i), field2.PointerSparseSharedUnmanaged(i), field3.PointerSparseSharedUnmanaged(i), field4.PointerSparseSharedUnmanaged(i), field5.PointerSparseSharedUnmanaged(i), field6.PointerSparseSharedUnmanaged(i), field7.PointerSparseSharedUnmanaged(i), field8.PointerSparseSharedUnmanaged(i), field9.PointerSparseSharedUnmanaged(i), field10.PointerSparseSharedUnmanaged(i), field11.PointerSparseSharedUnmanaged(i), field12.PointerSparseSharedUnmanaged(i), field13.PointerSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerManaged(i), field1.PointerManaged(i), field2.PointerManaged(i), field3.PointerManaged(i), field4.PointerManaged(i), field5.PointerManaged(i), field6.PointerManaged(i), field7.PointerManaged(i), field8.PointerManaged(i), field9.PointerManaged(i), field10.PointerManaged(i), field11.PointerManaged(i), field12.PointerManaged(i), field13.PointerManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSharedManaged(i), field1.PointerSharedManaged(i), field2.PointerSharedManaged(i), field3.PointerSharedManaged(i), field4.PointerSharedManaged(i), field5.PointerSharedManaged(i), field6.PointerSharedManaged(i), field7.PointerSharedManaged(i), field8.PointerSharedManaged(i), field9.PointerSharedManaged(i), field10.PointerSharedManaged(i), field11.PointerSharedManaged(i), field12.PointerSharedManaged(i), field13.PointerSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSparseManaged(i), field1.PointerSparseManaged(i), field2.PointerSparseManaged(i), field3.PointerSparseManaged(i), field4.PointerSparseManaged(i), field5.PointerSparseManaged(i), field6.PointerSparseManaged(i), field7.PointerSparseManaged(i), field8.PointerSparseManaged(i), field9.PointerSparseManaged(i), field10.PointerSparseManaged(i), field11.PointerSparseManaged(i), field12.PointerSparseManaged(i), field13.PointerSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSparseSharedManaged(i), field1.PointerSparseSharedManaged(i), field2.PointerSparseSharedManaged(i), field3.PointerSparseSharedManaged(i), field4.PointerSparseSharedManaged(i), field5.PointerSparseSharedManaged(i), field6.PointerSparseSharedManaged(i), field7.PointerSparseSharedManaged(i), field8.PointerSparseSharedManaged(i), field9.PointerSparseSharedManaged(i), field10.PointerSparseSharedManaged(i), field11.PointerSparseSharedManaged(i), field12.PointerSparseSharedManaged(i), field13.PointerSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 
     /// <summary>
@@ -296,25 +1288,135 @@ public static Entity Find<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8); byte* pointer9 = (byte*)it.GetPointer<T9>(9); byte* pointer10 = (byte*)it.GetPointer<T10>(10); byte* pointer11 = (byte*)it.GetPointer<T11>(11); byte* pointer12 = (byte*)it.GetPointer<T12>(12); byte* pointer13 = (byte*)it.GetPointer<T13>(13);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8); int step9 = it.Step<T9>(9); int step10 = it.Step<T10>(10); int step11 = it.Step<T11>(11); int step12 = it.Step<T12>(12); int step13 = it.Step<T13>(13);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8); FieldData<T9> field9 = it.GetFieldData<T9>(9); FieldData<T10> field10 = it.GetFieldData<T10>(10); FieldData<T11> field11 = it.GetFieldData<T11>(11); FieldData<T12> field12 = it.GetFieldData<T12>(12); FieldData<T13> field13 = it.GetFieldData<T13>(13);
+        IterationTechnique flags = it.GetIterationTechnique(14);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8], pointer9 = &pointer9[step9], pointer10 = &pointer10[step10], pointer11 = &pointer11[step11], pointer12 = &pointer12[step12], pointer13 = &pointer13[step13])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>() || RuntimeHelpers.IsReferenceOrContainsReferences<T9>() || RuntimeHelpers.IsReferenceOrContainsReferences<T10>() || RuntimeHelpers.IsReferenceOrContainsReferences<T11>() || RuntimeHelpers.IsReferenceOrContainsReferences<T12>() || RuntimeHelpers.IsReferenceOrContainsReferences<T13>())
         {
-            if (!callback((T0*)pointer0, (T1*)pointer1, (T2*)pointer2, (T3*)pointer3, (T4*)pointer4, (T5*)pointer5, (T6*)pointer6, (T7*)pointer7, (T8*)pointer8, (T9*)pointer9, (T10*)pointer10, (T11*)pointer11, (T12*)pointer12, (T13*)pointer13))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerUnmanaged(i), field1.PointerUnmanaged(i), field2.PointerUnmanaged(i), field3.PointerUnmanaged(i), field4.PointerUnmanaged(i), field5.PointerUnmanaged(i), field6.PointerUnmanaged(i), field7.PointerUnmanaged(i), field8.PointerUnmanaged(i), field9.PointerUnmanaged(i), field10.PointerUnmanaged(i), field11.PointerUnmanaged(i), field12.PointerUnmanaged(i), field13.PointerUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSharedUnmanaged(i), field1.PointerSharedUnmanaged(i), field2.PointerSharedUnmanaged(i), field3.PointerSharedUnmanaged(i), field4.PointerSharedUnmanaged(i), field5.PointerSharedUnmanaged(i), field6.PointerSharedUnmanaged(i), field7.PointerSharedUnmanaged(i), field8.PointerSharedUnmanaged(i), field9.PointerSharedUnmanaged(i), field10.PointerSharedUnmanaged(i), field11.PointerSharedUnmanaged(i), field12.PointerSharedUnmanaged(i), field13.PointerSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSparseUnmanaged(i), field1.PointerSparseUnmanaged(i), field2.PointerSparseUnmanaged(i), field3.PointerSparseUnmanaged(i), field4.PointerSparseUnmanaged(i), field5.PointerSparseUnmanaged(i), field6.PointerSparseUnmanaged(i), field7.PointerSparseUnmanaged(i), field8.PointerSparseUnmanaged(i), field9.PointerSparseUnmanaged(i), field10.PointerSparseUnmanaged(i), field11.PointerSparseUnmanaged(i), field12.PointerSparseUnmanaged(i), field13.PointerSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSparseSharedUnmanaged(i), field1.PointerSparseSharedUnmanaged(i), field2.PointerSparseSharedUnmanaged(i), field3.PointerSparseSharedUnmanaged(i), field4.PointerSparseSharedUnmanaged(i), field5.PointerSparseSharedUnmanaged(i), field6.PointerSparseSharedUnmanaged(i), field7.PointerSparseSharedUnmanaged(i), field8.PointerSparseSharedUnmanaged(i), field9.PointerSparseSharedUnmanaged(i), field10.PointerSparseSharedUnmanaged(i), field11.PointerSparseSharedUnmanaged(i), field12.PointerSparseSharedUnmanaged(i), field13.PointerSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerManaged(i), field1.PointerManaged(i), field2.PointerManaged(i), field3.PointerManaged(i), field4.PointerManaged(i), field5.PointerManaged(i), field6.PointerManaged(i), field7.PointerManaged(i), field8.PointerManaged(i), field9.PointerManaged(i), field10.PointerManaged(i), field11.PointerManaged(i), field12.PointerManaged(i), field13.PointerManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSharedManaged(i), field1.PointerSharedManaged(i), field2.PointerSharedManaged(i), field3.PointerSharedManaged(i), field4.PointerSharedManaged(i), field5.PointerSharedManaged(i), field6.PointerSharedManaged(i), field7.PointerSharedManaged(i), field8.PointerSharedManaged(i), field9.PointerSharedManaged(i), field10.PointerSharedManaged(i), field11.PointerSharedManaged(i), field12.PointerSharedManaged(i), field13.PointerSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSparseManaged(i), field1.PointerSparseManaged(i), field2.PointerSparseManaged(i), field3.PointerSparseManaged(i), field4.PointerSparseManaged(i), field5.PointerSparseManaged(i), field6.PointerSparseManaged(i), field7.PointerSparseManaged(i), field8.PointerSparseManaged(i), field9.PointerSparseManaged(i), field10.PointerSparseManaged(i), field11.PointerSparseManaged(i), field12.PointerSparseManaged(i), field13.PointerSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSparseSharedManaged(i), field1.PointerSparseSharedManaged(i), field2.PointerSparseSharedManaged(i), field3.PointerSparseSharedManaged(i), field4.PointerSparseSharedManaged(i), field5.PointerSparseSharedManaged(i), field6.PointerSparseSharedManaged(i), field7.PointerSparseSharedManaged(i), field8.PointerSparseSharedManaged(i), field9.PointerSparseSharedManaged(i), field10.PointerSparseSharedManaged(i), field11.PointerSparseSharedManaged(i), field12.PointerSparseSharedManaged(i), field13.PointerSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 
     /// <summary>
@@ -327,25 +1429,135 @@ public static Entity Find<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
     {
         int count = it.Handle->count; Ecs.Assert(it.Handle->count > 0, "No entities returned, use Iter() or Each() without the entity argument instead.");
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8); byte* pointer9 = (byte*)it.GetPointer<T9>(9); byte* pointer10 = (byte*)it.GetPointer<T10>(10); byte* pointer11 = (byte*)it.GetPointer<T11>(11); byte* pointer12 = (byte*)it.GetPointer<T12>(12); byte* pointer13 = (byte*)it.GetPointer<T13>(13);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8); int step9 = it.Step<T9>(9); int step10 = it.Step<T10>(10); int step11 = it.Step<T11>(11); int step12 = it.Step<T12>(12); int step13 = it.Step<T13>(13);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8); FieldData<T9> field9 = it.GetFieldData<T9>(9); FieldData<T10> field10 = it.GetFieldData<T10>(10); FieldData<T11> field11 = it.GetFieldData<T11>(11); FieldData<T12> field12 = it.GetFieldData<T12>(12); FieldData<T13> field13 = it.GetFieldData<T13>(13);
+        IterationTechnique flags = it.GetIterationTechnique(14);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8], pointer9 = &pointer9[step9], pointer10 = &pointer10[step10], pointer11 = &pointer11[step11], pointer12 = &pointer12[step12], pointer13 = &pointer13[step13])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>() || RuntimeHelpers.IsReferenceOrContainsReferences<T9>() || RuntimeHelpers.IsReferenceOrContainsReferences<T10>() || RuntimeHelpers.IsReferenceOrContainsReferences<T11>() || RuntimeHelpers.IsReferenceOrContainsReferences<T12>() || RuntimeHelpers.IsReferenceOrContainsReferences<T13>())
         {
-            if (!callback(new Entity(it.Handle->world, it.Handle->entities[i]), (T0*)pointer0, (T1*)pointer1, (T2*)pointer2, (T3*)pointer3, (T4*)pointer4, (T5*)pointer5, (T6*)pointer6, (T7*)pointer7, (T8*)pointer8, (T9*)pointer9, (T10*)pointer10, (T11*)pointer11, (T12*)pointer12, (T13*)pointer13))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerUnmanaged(i), field1.PointerUnmanaged(i), field2.PointerUnmanaged(i), field3.PointerUnmanaged(i), field4.PointerUnmanaged(i), field5.PointerUnmanaged(i), field6.PointerUnmanaged(i), field7.PointerUnmanaged(i), field8.PointerUnmanaged(i), field9.PointerUnmanaged(i), field10.PointerUnmanaged(i), field11.PointerUnmanaged(i), field12.PointerUnmanaged(i), field13.PointerUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSharedUnmanaged(i), field1.PointerSharedUnmanaged(i), field2.PointerSharedUnmanaged(i), field3.PointerSharedUnmanaged(i), field4.PointerSharedUnmanaged(i), field5.PointerSharedUnmanaged(i), field6.PointerSharedUnmanaged(i), field7.PointerSharedUnmanaged(i), field8.PointerSharedUnmanaged(i), field9.PointerSharedUnmanaged(i), field10.PointerSharedUnmanaged(i), field11.PointerSharedUnmanaged(i), field12.PointerSharedUnmanaged(i), field13.PointerSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseUnmanaged(i), field1.PointerSparseUnmanaged(i), field2.PointerSparseUnmanaged(i), field3.PointerSparseUnmanaged(i), field4.PointerSparseUnmanaged(i), field5.PointerSparseUnmanaged(i), field6.PointerSparseUnmanaged(i), field7.PointerSparseUnmanaged(i), field8.PointerSparseUnmanaged(i), field9.PointerSparseUnmanaged(i), field10.PointerSparseUnmanaged(i), field11.PointerSparseUnmanaged(i), field12.PointerSparseUnmanaged(i), field13.PointerSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseSharedUnmanaged(i), field1.PointerSparseSharedUnmanaged(i), field2.PointerSparseSharedUnmanaged(i), field3.PointerSparseSharedUnmanaged(i), field4.PointerSparseSharedUnmanaged(i), field5.PointerSparseSharedUnmanaged(i), field6.PointerSparseSharedUnmanaged(i), field7.PointerSparseSharedUnmanaged(i), field8.PointerSparseSharedUnmanaged(i), field9.PointerSparseSharedUnmanaged(i), field10.PointerSparseSharedUnmanaged(i), field11.PointerSparseSharedUnmanaged(i), field12.PointerSparseSharedUnmanaged(i), field13.PointerSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerManaged(i), field1.PointerManaged(i), field2.PointerManaged(i), field3.PointerManaged(i), field4.PointerManaged(i), field5.PointerManaged(i), field6.PointerManaged(i), field7.PointerManaged(i), field8.PointerManaged(i), field9.PointerManaged(i), field10.PointerManaged(i), field11.PointerManaged(i), field12.PointerManaged(i), field13.PointerManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSharedManaged(i), field1.PointerSharedManaged(i), field2.PointerSharedManaged(i), field3.PointerSharedManaged(i), field4.PointerSharedManaged(i), field5.PointerSharedManaged(i), field6.PointerSharedManaged(i), field7.PointerSharedManaged(i), field8.PointerSharedManaged(i), field9.PointerSharedManaged(i), field10.PointerSharedManaged(i), field11.PointerSharedManaged(i), field12.PointerSharedManaged(i), field13.PointerSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseManaged(i), field1.PointerSparseManaged(i), field2.PointerSparseManaged(i), field3.PointerSparseManaged(i), field4.PointerSparseManaged(i), field5.PointerSparseManaged(i), field6.PointerSparseManaged(i), field7.PointerSparseManaged(i), field8.PointerSparseManaged(i), field9.PointerSparseManaged(i), field10.PointerSparseManaged(i), field11.PointerSparseManaged(i), field12.PointerSparseManaged(i), field13.PointerSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseSharedManaged(i), field1.PointerSparseSharedManaged(i), field2.PointerSparseSharedManaged(i), field3.PointerSparseSharedManaged(i), field4.PointerSparseSharedManaged(i), field5.PointerSparseSharedManaged(i), field6.PointerSparseSharedManaged(i), field7.PointerSparseSharedManaged(i), field8.PointerSparseSharedManaged(i), field9.PointerSparseSharedManaged(i), field10.PointerSparseSharedManaged(i), field11.PointerSparseSharedManaged(i), field12.PointerSparseSharedManaged(i), field13.PointerSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 
     /// <summary>
@@ -358,24 +1570,134 @@ public static Entity Find<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8); byte* pointer9 = (byte*)it.GetPointer<T9>(9); byte* pointer10 = (byte*)it.GetPointer<T10>(10); byte* pointer11 = (byte*)it.GetPointer<T11>(11); byte* pointer12 = (byte*)it.GetPointer<T12>(12); byte* pointer13 = (byte*)it.GetPointer<T13>(13);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8); int step9 = it.Step<T9>(9); int step10 = it.Step<T10>(10); int step11 = it.Step<T11>(11); int step12 = it.Step<T12>(12); int step13 = it.Step<T13>(13);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8); FieldData<T9> field9 = it.GetFieldData<T9>(9); FieldData<T10> field10 = it.GetFieldData<T10>(10); FieldData<T11> field11 = it.GetFieldData<T11>(11); FieldData<T12> field12 = it.GetFieldData<T12>(12); FieldData<T13> field13 = it.GetFieldData<T13>(13);
+        IterationTechnique flags = it.GetIterationTechnique(14);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8], pointer9 = &pointer9[step9], pointer10 = &pointer10[step10], pointer11 = &pointer11[step11], pointer12 = &pointer12[step12], pointer13 = &pointer13[step13])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>() || RuntimeHelpers.IsReferenceOrContainsReferences<T9>() || RuntimeHelpers.IsReferenceOrContainsReferences<T10>() || RuntimeHelpers.IsReferenceOrContainsReferences<T11>() || RuntimeHelpers.IsReferenceOrContainsReferences<T12>() || RuntimeHelpers.IsReferenceOrContainsReferences<T13>())
         {
-            if (!callback(it, i, (T0*)pointer0, (T1*)pointer1, (T2*)pointer2, (T3*)pointer3, (T4*)pointer4, (T5*)pointer5, (T6*)pointer6, (T7*)pointer7, (T8*)pointer8, (T9*)pointer9, (T10*)pointer10, (T11*)pointer11, (T12*)pointer12, (T13*)pointer13))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerUnmanaged(i), field1.PointerUnmanaged(i), field2.PointerUnmanaged(i), field3.PointerUnmanaged(i), field4.PointerUnmanaged(i), field5.PointerUnmanaged(i), field6.PointerUnmanaged(i), field7.PointerUnmanaged(i), field8.PointerUnmanaged(i), field9.PointerUnmanaged(i), field10.PointerUnmanaged(i), field11.PointerUnmanaged(i), field12.PointerUnmanaged(i), field13.PointerUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSharedUnmanaged(i), field1.PointerSharedUnmanaged(i), field2.PointerSharedUnmanaged(i), field3.PointerSharedUnmanaged(i), field4.PointerSharedUnmanaged(i), field5.PointerSharedUnmanaged(i), field6.PointerSharedUnmanaged(i), field7.PointerSharedUnmanaged(i), field8.PointerSharedUnmanaged(i), field9.PointerSharedUnmanaged(i), field10.PointerSharedUnmanaged(i), field11.PointerSharedUnmanaged(i), field12.PointerSharedUnmanaged(i), field13.PointerSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSparseUnmanaged(i), field1.PointerSparseUnmanaged(i), field2.PointerSparseUnmanaged(i), field3.PointerSparseUnmanaged(i), field4.PointerSparseUnmanaged(i), field5.PointerSparseUnmanaged(i), field6.PointerSparseUnmanaged(i), field7.PointerSparseUnmanaged(i), field8.PointerSparseUnmanaged(i), field9.PointerSparseUnmanaged(i), field10.PointerSparseUnmanaged(i), field11.PointerSparseUnmanaged(i), field12.PointerSparseUnmanaged(i), field13.PointerSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSparseSharedUnmanaged(i), field1.PointerSparseSharedUnmanaged(i), field2.PointerSparseSharedUnmanaged(i), field3.PointerSparseSharedUnmanaged(i), field4.PointerSparseSharedUnmanaged(i), field5.PointerSparseSharedUnmanaged(i), field6.PointerSparseSharedUnmanaged(i), field7.PointerSparseSharedUnmanaged(i), field8.PointerSparseSharedUnmanaged(i), field9.PointerSparseSharedUnmanaged(i), field10.PointerSparseSharedUnmanaged(i), field11.PointerSparseSharedUnmanaged(i), field12.PointerSparseSharedUnmanaged(i), field13.PointerSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerManaged(i), field1.PointerManaged(i), field2.PointerManaged(i), field3.PointerManaged(i), field4.PointerManaged(i), field5.PointerManaged(i), field6.PointerManaged(i), field7.PointerManaged(i), field8.PointerManaged(i), field9.PointerManaged(i), field10.PointerManaged(i), field11.PointerManaged(i), field12.PointerManaged(i), field13.PointerManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSharedManaged(i), field1.PointerSharedManaged(i), field2.PointerSharedManaged(i), field3.PointerSharedManaged(i), field4.PointerSharedManaged(i), field5.PointerSharedManaged(i), field6.PointerSharedManaged(i), field7.PointerSharedManaged(i), field8.PointerSharedManaged(i), field9.PointerSharedManaged(i), field10.PointerSharedManaged(i), field11.PointerSharedManaged(i), field12.PointerSharedManaged(i), field13.PointerSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSparseManaged(i), field1.PointerSparseManaged(i), field2.PointerSparseManaged(i), field3.PointerSparseManaged(i), field4.PointerSparseManaged(i), field5.PointerSparseManaged(i), field6.PointerSparseManaged(i), field7.PointerSparseManaged(i), field8.PointerSparseManaged(i), field9.PointerSparseManaged(i), field10.PointerSparseManaged(i), field11.PointerSparseManaged(i), field12.PointerSparseManaged(i), field13.PointerSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSparseSharedManaged(i), field1.PointerSparseSharedManaged(i), field2.PointerSparseSharedManaged(i), field3.PointerSparseSharedManaged(i), field4.PointerSparseSharedManaged(i), field5.PointerSparseSharedManaged(i), field6.PointerSparseSharedManaged(i), field7.PointerSparseSharedManaged(i), field8.PointerSparseSharedManaged(i), field9.PointerSparseSharedManaged(i), field10.PointerSparseSharedManaged(i), field11.PointerSparseSharedManaged(i), field12.PointerSparseSharedManaged(i), field13.PointerSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 }
\ No newline at end of file
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/Invoker/Find/Iterator/T15.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/Invoker/Find/Iterator/T15.g.cs
index 1410fcb6..4fcca619 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/Invoker/Find/Iterator/T15.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/Invoker/Find/Iterator/T15.g.cs
@@ -1,5 +1,7 @@
 // Find/Iterator/T15.g.cs
 // File was auto-generated by /_/src/Flecs.NET.Codegen/Generators/Invoker.cs
+using System;
+using System.Runtime.CompilerServices;
 using Flecs.NET.Utilities;
 using static Flecs.NET.Bindings.flecs;
 
@@ -17,25 +19,135 @@ public static Entity Find<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8); byte* pointer9 = (byte*)it.GetPointer<T9>(9); byte* pointer10 = (byte*)it.GetPointer<T10>(10); byte* pointer11 = (byte*)it.GetPointer<T11>(11); byte* pointer12 = (byte*)it.GetPointer<T12>(12); byte* pointer13 = (byte*)it.GetPointer<T13>(13); byte* pointer14 = (byte*)it.GetPointer<T14>(14);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8); int step9 = it.Step<T9>(9); int step10 = it.Step<T10>(10); int step11 = it.Step<T11>(11); int step12 = it.Step<T12>(12); int step13 = it.Step<T13>(13); int step14 = it.Step<T14>(14);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8); FieldData<T9> field9 = it.GetFieldData<T9>(9); FieldData<T10> field10 = it.GetFieldData<T10>(10); FieldData<T11> field11 = it.GetFieldData<T11>(11); FieldData<T12> field12 = it.GetFieldData<T12>(12); FieldData<T13> field13 = it.GetFieldData<T13>(13); FieldData<T14> field14 = it.GetFieldData<T14>(14);
+        IterationTechnique flags = it.GetIterationTechnique(15);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8], pointer9 = &pointer9[step9], pointer10 = &pointer10[step10], pointer11 = &pointer11[step11], pointer12 = &pointer12[step12], pointer13 = &pointer13[step13], pointer14 = &pointer14[step14])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>() || RuntimeHelpers.IsReferenceOrContainsReferences<T9>() || RuntimeHelpers.IsReferenceOrContainsReferences<T10>() || RuntimeHelpers.IsReferenceOrContainsReferences<T11>() || RuntimeHelpers.IsReferenceOrContainsReferences<T12>() || RuntimeHelpers.IsReferenceOrContainsReferences<T13>() || RuntimeHelpers.IsReferenceOrContainsReferences<T14>())
         {
-            if (!callback(ref Managed.GetTypeRef<T0>(pointer0), ref Managed.GetTypeRef<T1>(pointer1), ref Managed.GetTypeRef<T2>(pointer2), ref Managed.GetTypeRef<T3>(pointer3), ref Managed.GetTypeRef<T4>(pointer4), ref Managed.GetTypeRef<T5>(pointer5), ref Managed.GetTypeRef<T6>(pointer6), ref Managed.GetTypeRef<T7>(pointer7), ref Managed.GetTypeRef<T8>(pointer8), ref Managed.GetTypeRef<T9>(pointer9), ref Managed.GetTypeRef<T10>(pointer10), ref Managed.GetTypeRef<T11>(pointer11), ref Managed.GetTypeRef<T12>(pointer12), ref Managed.GetTypeRef<T13>(pointer13), ref Managed.GetTypeRef<T14>(pointer14)))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, Ecs.FindRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefUnmanaged(i), ref field1.RefUnmanaged(i), ref field2.RefUnmanaged(i), ref field3.RefUnmanaged(i), ref field4.RefUnmanaged(i), ref field5.RefUnmanaged(i), ref field6.RefUnmanaged(i), ref field7.RefUnmanaged(i), ref field8.RefUnmanaged(i), ref field9.RefUnmanaged(i), ref field10.RefUnmanaged(i), ref field11.RefUnmanaged(i), ref field12.RefUnmanaged(i), ref field13.RefUnmanaged(i), ref field14.RefUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, Ecs.FindRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSharedUnmanaged(i), ref field1.RefSharedUnmanaged(i), ref field2.RefSharedUnmanaged(i), ref field3.RefSharedUnmanaged(i), ref field4.RefSharedUnmanaged(i), ref field5.RefSharedUnmanaged(i), ref field6.RefSharedUnmanaged(i), ref field7.RefSharedUnmanaged(i), ref field8.RefSharedUnmanaged(i), ref field9.RefSharedUnmanaged(i), ref field10.RefSharedUnmanaged(i), ref field11.RefSharedUnmanaged(i), ref field12.RefSharedUnmanaged(i), ref field13.RefSharedUnmanaged(i), ref field14.RefSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, Ecs.FindRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSparseUnmanaged(i), ref field1.RefSparseUnmanaged(i), ref field2.RefSparseUnmanaged(i), ref field3.RefSparseUnmanaged(i), ref field4.RefSparseUnmanaged(i), ref field5.RefSparseUnmanaged(i), ref field6.RefSparseUnmanaged(i), ref field7.RefSparseUnmanaged(i), ref field8.RefSparseUnmanaged(i), ref field9.RefSparseUnmanaged(i), ref field10.RefSparseUnmanaged(i), ref field11.RefSparseUnmanaged(i), ref field12.RefSparseUnmanaged(i), ref field13.RefSparseUnmanaged(i), ref field14.RefSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, Ecs.FindRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSparseSharedUnmanaged(i), ref field1.RefSparseSharedUnmanaged(i), ref field2.RefSparseSharedUnmanaged(i), ref field3.RefSparseSharedUnmanaged(i), ref field4.RefSparseSharedUnmanaged(i), ref field5.RefSparseSharedUnmanaged(i), ref field6.RefSparseSharedUnmanaged(i), ref field7.RefSparseSharedUnmanaged(i), ref field8.RefSparseSharedUnmanaged(i), ref field9.RefSparseSharedUnmanaged(i), ref field10.RefSparseSharedUnmanaged(i), ref field11.RefSparseSharedUnmanaged(i), ref field12.RefSparseSharedUnmanaged(i), ref field13.RefSparseSharedUnmanaged(i), ref field14.RefSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, Ecs.FindRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefManaged(i), ref field1.RefManaged(i), ref field2.RefManaged(i), ref field3.RefManaged(i), ref field4.RefManaged(i), ref field5.RefManaged(i), ref field6.RefManaged(i), ref field7.RefManaged(i), ref field8.RefManaged(i), ref field9.RefManaged(i), ref field10.RefManaged(i), ref field11.RefManaged(i), ref field12.RefManaged(i), ref field13.RefManaged(i), ref field14.RefManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, Ecs.FindRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSharedManaged(i), ref field1.RefSharedManaged(i), ref field2.RefSharedManaged(i), ref field3.RefSharedManaged(i), ref field4.RefSharedManaged(i), ref field5.RefSharedManaged(i), ref field6.RefSharedManaged(i), ref field7.RefSharedManaged(i), ref field8.RefSharedManaged(i), ref field9.RefSharedManaged(i), ref field10.RefSharedManaged(i), ref field11.RefSharedManaged(i), ref field12.RefSharedManaged(i), ref field13.RefSharedManaged(i), ref field14.RefSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, Ecs.FindRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSparseManaged(i), ref field1.RefSparseManaged(i), ref field2.RefSparseManaged(i), ref field3.RefSparseManaged(i), ref field4.RefSparseManaged(i), ref field5.RefSparseManaged(i), ref field6.RefSparseManaged(i), ref field7.RefSparseManaged(i), ref field8.RefSparseManaged(i), ref field9.RefSparseManaged(i), ref field10.RefSparseManaged(i), ref field11.RefSparseManaged(i), ref field12.RefSparseManaged(i), ref field13.RefSparseManaged(i), ref field14.RefSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, Ecs.FindRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSparseSharedManaged(i), ref field1.RefSparseSharedManaged(i), ref field2.RefSparseSharedManaged(i), ref field3.RefSparseSharedManaged(i), ref field4.RefSparseSharedManaged(i), ref field5.RefSparseSharedManaged(i), ref field6.RefSparseSharedManaged(i), ref field7.RefSparseSharedManaged(i), ref field8.RefSparseSharedManaged(i), ref field9.RefSparseSharedManaged(i), ref field10.RefSparseSharedManaged(i), ref field11.RefSparseSharedManaged(i), ref field12.RefSparseSharedManaged(i), ref field13.RefSparseSharedManaged(i), ref field14.RefSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 
     /// <summary>
@@ -48,25 +160,135 @@ public static Entity Find<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
     {
         int count = it.Handle->count; Ecs.Assert(it.Handle->count > 0, "No entities returned, use Iter() or Each() without the entity argument instead.");
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8); byte* pointer9 = (byte*)it.GetPointer<T9>(9); byte* pointer10 = (byte*)it.GetPointer<T10>(10); byte* pointer11 = (byte*)it.GetPointer<T11>(11); byte* pointer12 = (byte*)it.GetPointer<T12>(12); byte* pointer13 = (byte*)it.GetPointer<T13>(13); byte* pointer14 = (byte*)it.GetPointer<T14>(14);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8); int step9 = it.Step<T9>(9); int step10 = it.Step<T10>(10); int step11 = it.Step<T11>(11); int step12 = it.Step<T12>(12); int step13 = it.Step<T13>(13); int step14 = it.Step<T14>(14);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8); FieldData<T9> field9 = it.GetFieldData<T9>(9); FieldData<T10> field10 = it.GetFieldData<T10>(10); FieldData<T11> field11 = it.GetFieldData<T11>(11); FieldData<T12> field12 = it.GetFieldData<T12>(12); FieldData<T13> field13 = it.GetFieldData<T13>(13); FieldData<T14> field14 = it.GetFieldData<T14>(14);
+        IterationTechnique flags = it.GetIterationTechnique(15);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8], pointer9 = &pointer9[step9], pointer10 = &pointer10[step10], pointer11 = &pointer11[step11], pointer12 = &pointer12[step12], pointer13 = &pointer13[step13], pointer14 = &pointer14[step14])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>() || RuntimeHelpers.IsReferenceOrContainsReferences<T9>() || RuntimeHelpers.IsReferenceOrContainsReferences<T10>() || RuntimeHelpers.IsReferenceOrContainsReferences<T11>() || RuntimeHelpers.IsReferenceOrContainsReferences<T12>() || RuntimeHelpers.IsReferenceOrContainsReferences<T13>() || RuntimeHelpers.IsReferenceOrContainsReferences<T14>())
         {
-            if (!callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref Managed.GetTypeRef<T0>(pointer0), ref Managed.GetTypeRef<T1>(pointer1), ref Managed.GetTypeRef<T2>(pointer2), ref Managed.GetTypeRef<T3>(pointer3), ref Managed.GetTypeRef<T4>(pointer4), ref Managed.GetTypeRef<T5>(pointer5), ref Managed.GetTypeRef<T6>(pointer6), ref Managed.GetTypeRef<T7>(pointer7), ref Managed.GetTypeRef<T8>(pointer8), ref Managed.GetTypeRef<T9>(pointer9), ref Managed.GetTypeRef<T10>(pointer10), ref Managed.GetTypeRef<T11>(pointer11), ref Managed.GetTypeRef<T12>(pointer12), ref Managed.GetTypeRef<T13>(pointer13), ref Managed.GetTypeRef<T14>(pointer14)))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefUnmanaged(i), ref field1.RefUnmanaged(i), ref field2.RefUnmanaged(i), ref field3.RefUnmanaged(i), ref field4.RefUnmanaged(i), ref field5.RefUnmanaged(i), ref field6.RefUnmanaged(i), ref field7.RefUnmanaged(i), ref field8.RefUnmanaged(i), ref field9.RefUnmanaged(i), ref field10.RefUnmanaged(i), ref field11.RefUnmanaged(i), ref field12.RefUnmanaged(i), ref field13.RefUnmanaged(i), ref field14.RefUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSharedUnmanaged(i), ref field1.RefSharedUnmanaged(i), ref field2.RefSharedUnmanaged(i), ref field3.RefSharedUnmanaged(i), ref field4.RefSharedUnmanaged(i), ref field5.RefSharedUnmanaged(i), ref field6.RefSharedUnmanaged(i), ref field7.RefSharedUnmanaged(i), ref field8.RefSharedUnmanaged(i), ref field9.RefSharedUnmanaged(i), ref field10.RefSharedUnmanaged(i), ref field11.RefSharedUnmanaged(i), ref field12.RefSharedUnmanaged(i), ref field13.RefSharedUnmanaged(i), ref field14.RefSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseUnmanaged(i), ref field1.RefSparseUnmanaged(i), ref field2.RefSparseUnmanaged(i), ref field3.RefSparseUnmanaged(i), ref field4.RefSparseUnmanaged(i), ref field5.RefSparseUnmanaged(i), ref field6.RefSparseUnmanaged(i), ref field7.RefSparseUnmanaged(i), ref field8.RefSparseUnmanaged(i), ref field9.RefSparseUnmanaged(i), ref field10.RefSparseUnmanaged(i), ref field11.RefSparseUnmanaged(i), ref field12.RefSparseUnmanaged(i), ref field13.RefSparseUnmanaged(i), ref field14.RefSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseSharedUnmanaged(i), ref field1.RefSparseSharedUnmanaged(i), ref field2.RefSparseSharedUnmanaged(i), ref field3.RefSparseSharedUnmanaged(i), ref field4.RefSparseSharedUnmanaged(i), ref field5.RefSparseSharedUnmanaged(i), ref field6.RefSparseSharedUnmanaged(i), ref field7.RefSparseSharedUnmanaged(i), ref field8.RefSparseSharedUnmanaged(i), ref field9.RefSparseSharedUnmanaged(i), ref field10.RefSparseSharedUnmanaged(i), ref field11.RefSparseSharedUnmanaged(i), ref field12.RefSparseSharedUnmanaged(i), ref field13.RefSparseSharedUnmanaged(i), ref field14.RefSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefManaged(i), ref field1.RefManaged(i), ref field2.RefManaged(i), ref field3.RefManaged(i), ref field4.RefManaged(i), ref field5.RefManaged(i), ref field6.RefManaged(i), ref field7.RefManaged(i), ref field8.RefManaged(i), ref field9.RefManaged(i), ref field10.RefManaged(i), ref field11.RefManaged(i), ref field12.RefManaged(i), ref field13.RefManaged(i), ref field14.RefManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSharedManaged(i), ref field1.RefSharedManaged(i), ref field2.RefSharedManaged(i), ref field3.RefSharedManaged(i), ref field4.RefSharedManaged(i), ref field5.RefSharedManaged(i), ref field6.RefSharedManaged(i), ref field7.RefSharedManaged(i), ref field8.RefSharedManaged(i), ref field9.RefSharedManaged(i), ref field10.RefSharedManaged(i), ref field11.RefSharedManaged(i), ref field12.RefSharedManaged(i), ref field13.RefSharedManaged(i), ref field14.RefSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseManaged(i), ref field1.RefSparseManaged(i), ref field2.RefSparseManaged(i), ref field3.RefSparseManaged(i), ref field4.RefSparseManaged(i), ref field5.RefSparseManaged(i), ref field6.RefSparseManaged(i), ref field7.RefSparseManaged(i), ref field8.RefSparseManaged(i), ref field9.RefSparseManaged(i), ref field10.RefSparseManaged(i), ref field11.RefSparseManaged(i), ref field12.RefSparseManaged(i), ref field13.RefSparseManaged(i), ref field14.RefSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseSharedManaged(i), ref field1.RefSparseSharedManaged(i), ref field2.RefSparseSharedManaged(i), ref field3.RefSparseSharedManaged(i), ref field4.RefSparseSharedManaged(i), ref field5.RefSparseSharedManaged(i), ref field6.RefSparseSharedManaged(i), ref field7.RefSparseSharedManaged(i), ref field8.RefSparseSharedManaged(i), ref field9.RefSparseSharedManaged(i), ref field10.RefSparseSharedManaged(i), ref field11.RefSparseSharedManaged(i), ref field12.RefSparseSharedManaged(i), ref field13.RefSparseSharedManaged(i), ref field14.RefSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 
     /// <summary>
@@ -79,25 +301,135 @@ public static Entity Find<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8); byte* pointer9 = (byte*)it.GetPointer<T9>(9); byte* pointer10 = (byte*)it.GetPointer<T10>(10); byte* pointer11 = (byte*)it.GetPointer<T11>(11); byte* pointer12 = (byte*)it.GetPointer<T12>(12); byte* pointer13 = (byte*)it.GetPointer<T13>(13); byte* pointer14 = (byte*)it.GetPointer<T14>(14);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8); int step9 = it.Step<T9>(9); int step10 = it.Step<T10>(10); int step11 = it.Step<T11>(11); int step12 = it.Step<T12>(12); int step13 = it.Step<T13>(13); int step14 = it.Step<T14>(14);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8); FieldData<T9> field9 = it.GetFieldData<T9>(9); FieldData<T10> field10 = it.GetFieldData<T10>(10); FieldData<T11> field11 = it.GetFieldData<T11>(11); FieldData<T12> field12 = it.GetFieldData<T12>(12); FieldData<T13> field13 = it.GetFieldData<T13>(13); FieldData<T14> field14 = it.GetFieldData<T14>(14);
+        IterationTechnique flags = it.GetIterationTechnique(15);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8], pointer9 = &pointer9[step9], pointer10 = &pointer10[step10], pointer11 = &pointer11[step11], pointer12 = &pointer12[step12], pointer13 = &pointer13[step13], pointer14 = &pointer14[step14])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>() || RuntimeHelpers.IsReferenceOrContainsReferences<T9>() || RuntimeHelpers.IsReferenceOrContainsReferences<T10>() || RuntimeHelpers.IsReferenceOrContainsReferences<T11>() || RuntimeHelpers.IsReferenceOrContainsReferences<T12>() || RuntimeHelpers.IsReferenceOrContainsReferences<T13>() || RuntimeHelpers.IsReferenceOrContainsReferences<T14>())
         {
-            if (!callback(it, i, ref Managed.GetTypeRef<T0>(pointer0), ref Managed.GetTypeRef<T1>(pointer1), ref Managed.GetTypeRef<T2>(pointer2), ref Managed.GetTypeRef<T3>(pointer3), ref Managed.GetTypeRef<T4>(pointer4), ref Managed.GetTypeRef<T5>(pointer5), ref Managed.GetTypeRef<T6>(pointer6), ref Managed.GetTypeRef<T7>(pointer7), ref Managed.GetTypeRef<T8>(pointer8), ref Managed.GetTypeRef<T9>(pointer9), ref Managed.GetTypeRef<T10>(pointer10), ref Managed.GetTypeRef<T11>(pointer11), ref Managed.GetTypeRef<T12>(pointer12), ref Managed.GetTypeRef<T13>(pointer13), ref Managed.GetTypeRef<T14>(pointer14)))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, Ecs.FindIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefUnmanaged(i), ref field1.RefUnmanaged(i), ref field2.RefUnmanaged(i), ref field3.RefUnmanaged(i), ref field4.RefUnmanaged(i), ref field5.RefUnmanaged(i), ref field6.RefUnmanaged(i), ref field7.RefUnmanaged(i), ref field8.RefUnmanaged(i), ref field9.RefUnmanaged(i), ref field10.RefUnmanaged(i), ref field11.RefUnmanaged(i), ref field12.RefUnmanaged(i), ref field13.RefUnmanaged(i), ref field14.RefUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, Ecs.FindIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSharedUnmanaged(i), ref field1.RefSharedUnmanaged(i), ref field2.RefSharedUnmanaged(i), ref field3.RefSharedUnmanaged(i), ref field4.RefSharedUnmanaged(i), ref field5.RefSharedUnmanaged(i), ref field6.RefSharedUnmanaged(i), ref field7.RefSharedUnmanaged(i), ref field8.RefSharedUnmanaged(i), ref field9.RefSharedUnmanaged(i), ref field10.RefSharedUnmanaged(i), ref field11.RefSharedUnmanaged(i), ref field12.RefSharedUnmanaged(i), ref field13.RefSharedUnmanaged(i), ref field14.RefSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, Ecs.FindIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSparseUnmanaged(i), ref field1.RefSparseUnmanaged(i), ref field2.RefSparseUnmanaged(i), ref field3.RefSparseUnmanaged(i), ref field4.RefSparseUnmanaged(i), ref field5.RefSparseUnmanaged(i), ref field6.RefSparseUnmanaged(i), ref field7.RefSparseUnmanaged(i), ref field8.RefSparseUnmanaged(i), ref field9.RefSparseUnmanaged(i), ref field10.RefSparseUnmanaged(i), ref field11.RefSparseUnmanaged(i), ref field12.RefSparseUnmanaged(i), ref field13.RefSparseUnmanaged(i), ref field14.RefSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, Ecs.FindIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSparseSharedUnmanaged(i), ref field1.RefSparseSharedUnmanaged(i), ref field2.RefSparseSharedUnmanaged(i), ref field3.RefSparseSharedUnmanaged(i), ref field4.RefSparseSharedUnmanaged(i), ref field5.RefSparseSharedUnmanaged(i), ref field6.RefSparseSharedUnmanaged(i), ref field7.RefSparseSharedUnmanaged(i), ref field8.RefSparseSharedUnmanaged(i), ref field9.RefSparseSharedUnmanaged(i), ref field10.RefSparseSharedUnmanaged(i), ref field11.RefSparseSharedUnmanaged(i), ref field12.RefSparseSharedUnmanaged(i), ref field13.RefSparseSharedUnmanaged(i), ref field14.RefSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, Ecs.FindIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefManaged(i), ref field1.RefManaged(i), ref field2.RefManaged(i), ref field3.RefManaged(i), ref field4.RefManaged(i), ref field5.RefManaged(i), ref field6.RefManaged(i), ref field7.RefManaged(i), ref field8.RefManaged(i), ref field9.RefManaged(i), ref field10.RefManaged(i), ref field11.RefManaged(i), ref field12.RefManaged(i), ref field13.RefManaged(i), ref field14.RefManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, Ecs.FindIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSharedManaged(i), ref field1.RefSharedManaged(i), ref field2.RefSharedManaged(i), ref field3.RefSharedManaged(i), ref field4.RefSharedManaged(i), ref field5.RefSharedManaged(i), ref field6.RefSharedManaged(i), ref field7.RefSharedManaged(i), ref field8.RefSharedManaged(i), ref field9.RefSharedManaged(i), ref field10.RefSharedManaged(i), ref field11.RefSharedManaged(i), ref field12.RefSharedManaged(i), ref field13.RefSharedManaged(i), ref field14.RefSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, Ecs.FindIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSparseManaged(i), ref field1.RefSparseManaged(i), ref field2.RefSparseManaged(i), ref field3.RefSparseManaged(i), ref field4.RefSparseManaged(i), ref field5.RefSparseManaged(i), ref field6.RefSparseManaged(i), ref field7.RefSparseManaged(i), ref field8.RefSparseManaged(i), ref field9.RefSparseManaged(i), ref field10.RefSparseManaged(i), ref field11.RefSparseManaged(i), ref field12.RefSparseManaged(i), ref field13.RefSparseManaged(i), ref field14.RefSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, Ecs.FindIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSparseSharedManaged(i), ref field1.RefSparseSharedManaged(i), ref field2.RefSparseSharedManaged(i), ref field3.RefSparseSharedManaged(i), ref field4.RefSparseSharedManaged(i), ref field5.RefSparseSharedManaged(i), ref field6.RefSparseSharedManaged(i), ref field7.RefSparseSharedManaged(i), ref field8.RefSparseSharedManaged(i), ref field9.RefSparseSharedManaged(i), ref field10.RefSparseSharedManaged(i), ref field11.RefSparseSharedManaged(i), ref field12.RefSparseSharedManaged(i), ref field13.RefSparseSharedManaged(i), ref field14.RefSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 
     /// <summary>
@@ -110,25 +442,135 @@ public static Entity Find<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8); byte* pointer9 = (byte*)it.GetPointer<T9>(9); byte* pointer10 = (byte*)it.GetPointer<T10>(10); byte* pointer11 = (byte*)it.GetPointer<T11>(11); byte* pointer12 = (byte*)it.GetPointer<T12>(12); byte* pointer13 = (byte*)it.GetPointer<T13>(13); byte* pointer14 = (byte*)it.GetPointer<T14>(14);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8); int step9 = it.Step<T9>(9); int step10 = it.Step<T10>(10); int step11 = it.Step<T11>(11); int step12 = it.Step<T12>(12); int step13 = it.Step<T13>(13); int step14 = it.Step<T14>(14);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8); FieldData<T9> field9 = it.GetFieldData<T9>(9); FieldData<T10> field10 = it.GetFieldData<T10>(10); FieldData<T11> field11 = it.GetFieldData<T11>(11); FieldData<T12> field12 = it.GetFieldData<T12>(12); FieldData<T13> field13 = it.GetFieldData<T13>(13); FieldData<T14> field14 = it.GetFieldData<T14>(14);
+        IterationTechnique flags = it.GetIterationTechnique(15);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8], pointer9 = &pointer9[step9], pointer10 = &pointer10[step10], pointer11 = &pointer11[step11], pointer12 = &pointer12[step12], pointer13 = &pointer13[step13], pointer14 = &pointer14[step14])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>() || RuntimeHelpers.IsReferenceOrContainsReferences<T9>() || RuntimeHelpers.IsReferenceOrContainsReferences<T10>() || RuntimeHelpers.IsReferenceOrContainsReferences<T11>() || RuntimeHelpers.IsReferenceOrContainsReferences<T12>() || RuntimeHelpers.IsReferenceOrContainsReferences<T13>() || RuntimeHelpers.IsReferenceOrContainsReferences<T14>())
         {
-            if (!callback(ref Managed.GetTypeRef<T0>(pointer0), ref Managed.GetTypeRef<T1>(pointer1), ref Managed.GetTypeRef<T2>(pointer2), ref Managed.GetTypeRef<T3>(pointer3), ref Managed.GetTypeRef<T4>(pointer4), ref Managed.GetTypeRef<T5>(pointer5), ref Managed.GetTypeRef<T6>(pointer6), ref Managed.GetTypeRef<T7>(pointer7), ref Managed.GetTypeRef<T8>(pointer8), ref Managed.GetTypeRef<T9>(pointer9), ref Managed.GetTypeRef<T10>(pointer10), ref Managed.GetTypeRef<T11>(pointer11), ref Managed.GetTypeRef<T12>(pointer12), ref Managed.GetTypeRef<T13>(pointer13), ref Managed.GetTypeRef<T14>(pointer14)))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, ref T14, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefUnmanaged(i), ref field1.RefUnmanaged(i), ref field2.RefUnmanaged(i), ref field3.RefUnmanaged(i), ref field4.RefUnmanaged(i), ref field5.RefUnmanaged(i), ref field6.RefUnmanaged(i), ref field7.RefUnmanaged(i), ref field8.RefUnmanaged(i), ref field9.RefUnmanaged(i), ref field10.RefUnmanaged(i), ref field11.RefUnmanaged(i), ref field12.RefUnmanaged(i), ref field13.RefUnmanaged(i), ref field14.RefUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, ref T14, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSharedUnmanaged(i), ref field1.RefSharedUnmanaged(i), ref field2.RefSharedUnmanaged(i), ref field3.RefSharedUnmanaged(i), ref field4.RefSharedUnmanaged(i), ref field5.RefSharedUnmanaged(i), ref field6.RefSharedUnmanaged(i), ref field7.RefSharedUnmanaged(i), ref field8.RefSharedUnmanaged(i), ref field9.RefSharedUnmanaged(i), ref field10.RefSharedUnmanaged(i), ref field11.RefSharedUnmanaged(i), ref field12.RefSharedUnmanaged(i), ref field13.RefSharedUnmanaged(i), ref field14.RefSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, ref T14, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSparseUnmanaged(i), ref field1.RefSparseUnmanaged(i), ref field2.RefSparseUnmanaged(i), ref field3.RefSparseUnmanaged(i), ref field4.RefSparseUnmanaged(i), ref field5.RefSparseUnmanaged(i), ref field6.RefSparseUnmanaged(i), ref field7.RefSparseUnmanaged(i), ref field8.RefSparseUnmanaged(i), ref field9.RefSparseUnmanaged(i), ref field10.RefSparseUnmanaged(i), ref field11.RefSparseUnmanaged(i), ref field12.RefSparseUnmanaged(i), ref field13.RefSparseUnmanaged(i), ref field14.RefSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, ref T14, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSparseSharedUnmanaged(i), ref field1.RefSparseSharedUnmanaged(i), ref field2.RefSparseSharedUnmanaged(i), ref field3.RefSparseSharedUnmanaged(i), ref field4.RefSparseSharedUnmanaged(i), ref field5.RefSparseSharedUnmanaged(i), ref field6.RefSparseSharedUnmanaged(i), ref field7.RefSparseSharedUnmanaged(i), ref field8.RefSparseSharedUnmanaged(i), ref field9.RefSparseSharedUnmanaged(i), ref field10.RefSparseSharedUnmanaged(i), ref field11.RefSparseSharedUnmanaged(i), ref field12.RefSparseSharedUnmanaged(i), ref field13.RefSparseSharedUnmanaged(i), ref field14.RefSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, ref T14, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefManaged(i), ref field1.RefManaged(i), ref field2.RefManaged(i), ref field3.RefManaged(i), ref field4.RefManaged(i), ref field5.RefManaged(i), ref field6.RefManaged(i), ref field7.RefManaged(i), ref field8.RefManaged(i), ref field9.RefManaged(i), ref field10.RefManaged(i), ref field11.RefManaged(i), ref field12.RefManaged(i), ref field13.RefManaged(i), ref field14.RefManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, ref T14, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSharedManaged(i), ref field1.RefSharedManaged(i), ref field2.RefSharedManaged(i), ref field3.RefSharedManaged(i), ref field4.RefSharedManaged(i), ref field5.RefSharedManaged(i), ref field6.RefSharedManaged(i), ref field7.RefSharedManaged(i), ref field8.RefSharedManaged(i), ref field9.RefSharedManaged(i), ref field10.RefSharedManaged(i), ref field11.RefSharedManaged(i), ref field12.RefSharedManaged(i), ref field13.RefSharedManaged(i), ref field14.RefSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, ref T14, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSparseManaged(i), ref field1.RefSparseManaged(i), ref field2.RefSparseManaged(i), ref field3.RefSparseManaged(i), ref field4.RefSparseManaged(i), ref field5.RefSparseManaged(i), ref field6.RefSparseManaged(i), ref field7.RefSparseManaged(i), ref field8.RefSparseManaged(i), ref field9.RefSparseManaged(i), ref field10.RefSparseManaged(i), ref field11.RefSparseManaged(i), ref field12.RefSparseManaged(i), ref field13.RefSparseManaged(i), ref field14.RefSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, ref T14, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSparseSharedManaged(i), ref field1.RefSparseSharedManaged(i), ref field2.RefSparseSharedManaged(i), ref field3.RefSparseSharedManaged(i), ref field4.RefSparseSharedManaged(i), ref field5.RefSparseSharedManaged(i), ref field6.RefSparseSharedManaged(i), ref field7.RefSparseSharedManaged(i), ref field8.RefSparseSharedManaged(i), ref field9.RefSparseSharedManaged(i), ref field10.RefSparseSharedManaged(i), ref field11.RefSparseSharedManaged(i), ref field12.RefSparseSharedManaged(i), ref field13.RefSparseSharedManaged(i), ref field14.RefSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 
     /// <summary>
@@ -141,25 +583,135 @@ public static Entity Find<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
     {
         int count = it.Handle->count; Ecs.Assert(it.Handle->count > 0, "No entities returned, use Iter() or Each() without the entity argument instead.");
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8); byte* pointer9 = (byte*)it.GetPointer<T9>(9); byte* pointer10 = (byte*)it.GetPointer<T10>(10); byte* pointer11 = (byte*)it.GetPointer<T11>(11); byte* pointer12 = (byte*)it.GetPointer<T12>(12); byte* pointer13 = (byte*)it.GetPointer<T13>(13); byte* pointer14 = (byte*)it.GetPointer<T14>(14);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8); int step9 = it.Step<T9>(9); int step10 = it.Step<T10>(10); int step11 = it.Step<T11>(11); int step12 = it.Step<T12>(12); int step13 = it.Step<T13>(13); int step14 = it.Step<T14>(14);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8); FieldData<T9> field9 = it.GetFieldData<T9>(9); FieldData<T10> field10 = it.GetFieldData<T10>(10); FieldData<T11> field11 = it.GetFieldData<T11>(11); FieldData<T12> field12 = it.GetFieldData<T12>(12); FieldData<T13> field13 = it.GetFieldData<T13>(13); FieldData<T14> field14 = it.GetFieldData<T14>(14);
+        IterationTechnique flags = it.GetIterationTechnique(15);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8], pointer9 = &pointer9[step9], pointer10 = &pointer10[step10], pointer11 = &pointer11[step11], pointer12 = &pointer12[step12], pointer13 = &pointer13[step13], pointer14 = &pointer14[step14])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>() || RuntimeHelpers.IsReferenceOrContainsReferences<T9>() || RuntimeHelpers.IsReferenceOrContainsReferences<T10>() || RuntimeHelpers.IsReferenceOrContainsReferences<T11>() || RuntimeHelpers.IsReferenceOrContainsReferences<T12>() || RuntimeHelpers.IsReferenceOrContainsReferences<T13>() || RuntimeHelpers.IsReferenceOrContainsReferences<T14>())
         {
-            if (!callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref Managed.GetTypeRef<T0>(pointer0), ref Managed.GetTypeRef<T1>(pointer1), ref Managed.GetTypeRef<T2>(pointer2), ref Managed.GetTypeRef<T3>(pointer3), ref Managed.GetTypeRef<T4>(pointer4), ref Managed.GetTypeRef<T5>(pointer5), ref Managed.GetTypeRef<T6>(pointer6), ref Managed.GetTypeRef<T7>(pointer7), ref Managed.GetTypeRef<T8>(pointer8), ref Managed.GetTypeRef<T9>(pointer9), ref Managed.GetTypeRef<T10>(pointer10), ref Managed.GetTypeRef<T11>(pointer11), ref Managed.GetTypeRef<T12>(pointer12), ref Managed.GetTypeRef<T13>(pointer13), ref Managed.GetTypeRef<T14>(pointer14)))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, ref T14, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefUnmanaged(i), ref field1.RefUnmanaged(i), ref field2.RefUnmanaged(i), ref field3.RefUnmanaged(i), ref field4.RefUnmanaged(i), ref field5.RefUnmanaged(i), ref field6.RefUnmanaged(i), ref field7.RefUnmanaged(i), ref field8.RefUnmanaged(i), ref field9.RefUnmanaged(i), ref field10.RefUnmanaged(i), ref field11.RefUnmanaged(i), ref field12.RefUnmanaged(i), ref field13.RefUnmanaged(i), ref field14.RefUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, ref T14, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSharedUnmanaged(i), ref field1.RefSharedUnmanaged(i), ref field2.RefSharedUnmanaged(i), ref field3.RefSharedUnmanaged(i), ref field4.RefSharedUnmanaged(i), ref field5.RefSharedUnmanaged(i), ref field6.RefSharedUnmanaged(i), ref field7.RefSharedUnmanaged(i), ref field8.RefSharedUnmanaged(i), ref field9.RefSharedUnmanaged(i), ref field10.RefSharedUnmanaged(i), ref field11.RefSharedUnmanaged(i), ref field12.RefSharedUnmanaged(i), ref field13.RefSharedUnmanaged(i), ref field14.RefSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, ref T14, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseUnmanaged(i), ref field1.RefSparseUnmanaged(i), ref field2.RefSparseUnmanaged(i), ref field3.RefSparseUnmanaged(i), ref field4.RefSparseUnmanaged(i), ref field5.RefSparseUnmanaged(i), ref field6.RefSparseUnmanaged(i), ref field7.RefSparseUnmanaged(i), ref field8.RefSparseUnmanaged(i), ref field9.RefSparseUnmanaged(i), ref field10.RefSparseUnmanaged(i), ref field11.RefSparseUnmanaged(i), ref field12.RefSparseUnmanaged(i), ref field13.RefSparseUnmanaged(i), ref field14.RefSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, ref T14, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseSharedUnmanaged(i), ref field1.RefSparseSharedUnmanaged(i), ref field2.RefSparseSharedUnmanaged(i), ref field3.RefSparseSharedUnmanaged(i), ref field4.RefSparseSharedUnmanaged(i), ref field5.RefSparseSharedUnmanaged(i), ref field6.RefSparseSharedUnmanaged(i), ref field7.RefSparseSharedUnmanaged(i), ref field8.RefSparseSharedUnmanaged(i), ref field9.RefSparseSharedUnmanaged(i), ref field10.RefSparseSharedUnmanaged(i), ref field11.RefSparseSharedUnmanaged(i), ref field12.RefSparseSharedUnmanaged(i), ref field13.RefSparseSharedUnmanaged(i), ref field14.RefSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, ref T14, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefManaged(i), ref field1.RefManaged(i), ref field2.RefManaged(i), ref field3.RefManaged(i), ref field4.RefManaged(i), ref field5.RefManaged(i), ref field6.RefManaged(i), ref field7.RefManaged(i), ref field8.RefManaged(i), ref field9.RefManaged(i), ref field10.RefManaged(i), ref field11.RefManaged(i), ref field12.RefManaged(i), ref field13.RefManaged(i), ref field14.RefManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, ref T14, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSharedManaged(i), ref field1.RefSharedManaged(i), ref field2.RefSharedManaged(i), ref field3.RefSharedManaged(i), ref field4.RefSharedManaged(i), ref field5.RefSharedManaged(i), ref field6.RefSharedManaged(i), ref field7.RefSharedManaged(i), ref field8.RefSharedManaged(i), ref field9.RefSharedManaged(i), ref field10.RefSharedManaged(i), ref field11.RefSharedManaged(i), ref field12.RefSharedManaged(i), ref field13.RefSharedManaged(i), ref field14.RefSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, ref T14, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseManaged(i), ref field1.RefSparseManaged(i), ref field2.RefSparseManaged(i), ref field3.RefSparseManaged(i), ref field4.RefSparseManaged(i), ref field5.RefSparseManaged(i), ref field6.RefSparseManaged(i), ref field7.RefSparseManaged(i), ref field8.RefSparseManaged(i), ref field9.RefSparseManaged(i), ref field10.RefSparseManaged(i), ref field11.RefSparseManaged(i), ref field12.RefSparseManaged(i), ref field13.RefSparseManaged(i), ref field14.RefSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, ref T14, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseSharedManaged(i), ref field1.RefSparseSharedManaged(i), ref field2.RefSparseSharedManaged(i), ref field3.RefSparseSharedManaged(i), ref field4.RefSparseSharedManaged(i), ref field5.RefSparseSharedManaged(i), ref field6.RefSparseSharedManaged(i), ref field7.RefSparseSharedManaged(i), ref field8.RefSparseSharedManaged(i), ref field9.RefSparseSharedManaged(i), ref field10.RefSparseSharedManaged(i), ref field11.RefSparseSharedManaged(i), ref field12.RefSparseSharedManaged(i), ref field13.RefSparseSharedManaged(i), ref field14.RefSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 
     /// <summary>
@@ -172,25 +724,135 @@ public static Entity Find<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8); byte* pointer9 = (byte*)it.GetPointer<T9>(9); byte* pointer10 = (byte*)it.GetPointer<T10>(10); byte* pointer11 = (byte*)it.GetPointer<T11>(11); byte* pointer12 = (byte*)it.GetPointer<T12>(12); byte* pointer13 = (byte*)it.GetPointer<T13>(13); byte* pointer14 = (byte*)it.GetPointer<T14>(14);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8); int step9 = it.Step<T9>(9); int step10 = it.Step<T10>(10); int step11 = it.Step<T11>(11); int step12 = it.Step<T12>(12); int step13 = it.Step<T13>(13); int step14 = it.Step<T14>(14);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8); FieldData<T9> field9 = it.GetFieldData<T9>(9); FieldData<T10> field10 = it.GetFieldData<T10>(10); FieldData<T11> field11 = it.GetFieldData<T11>(11); FieldData<T12> field12 = it.GetFieldData<T12>(12); FieldData<T13> field13 = it.GetFieldData<T13>(13); FieldData<T14> field14 = it.GetFieldData<T14>(14);
+        IterationTechnique flags = it.GetIterationTechnique(15);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8], pointer9 = &pointer9[step9], pointer10 = &pointer10[step10], pointer11 = &pointer11[step11], pointer12 = &pointer12[step12], pointer13 = &pointer13[step13], pointer14 = &pointer14[step14])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>() || RuntimeHelpers.IsReferenceOrContainsReferences<T9>() || RuntimeHelpers.IsReferenceOrContainsReferences<T10>() || RuntimeHelpers.IsReferenceOrContainsReferences<T11>() || RuntimeHelpers.IsReferenceOrContainsReferences<T12>() || RuntimeHelpers.IsReferenceOrContainsReferences<T13>() || RuntimeHelpers.IsReferenceOrContainsReferences<T14>())
         {
-            if (!callback(it, i, ref Managed.GetTypeRef<T0>(pointer0), ref Managed.GetTypeRef<T1>(pointer1), ref Managed.GetTypeRef<T2>(pointer2), ref Managed.GetTypeRef<T3>(pointer3), ref Managed.GetTypeRef<T4>(pointer4), ref Managed.GetTypeRef<T5>(pointer5), ref Managed.GetTypeRef<T6>(pointer6), ref Managed.GetTypeRef<T7>(pointer7), ref Managed.GetTypeRef<T8>(pointer8), ref Managed.GetTypeRef<T9>(pointer9), ref Managed.GetTypeRef<T10>(pointer10), ref Managed.GetTypeRef<T11>(pointer11), ref Managed.GetTypeRef<T12>(pointer12), ref Managed.GetTypeRef<T13>(pointer13), ref Managed.GetTypeRef<T14>(pointer14)))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, ref T14, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefUnmanaged(i), ref field1.RefUnmanaged(i), ref field2.RefUnmanaged(i), ref field3.RefUnmanaged(i), ref field4.RefUnmanaged(i), ref field5.RefUnmanaged(i), ref field6.RefUnmanaged(i), ref field7.RefUnmanaged(i), ref field8.RefUnmanaged(i), ref field9.RefUnmanaged(i), ref field10.RefUnmanaged(i), ref field11.RefUnmanaged(i), ref field12.RefUnmanaged(i), ref field13.RefUnmanaged(i), ref field14.RefUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, ref T14, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSharedUnmanaged(i), ref field1.RefSharedUnmanaged(i), ref field2.RefSharedUnmanaged(i), ref field3.RefSharedUnmanaged(i), ref field4.RefSharedUnmanaged(i), ref field5.RefSharedUnmanaged(i), ref field6.RefSharedUnmanaged(i), ref field7.RefSharedUnmanaged(i), ref field8.RefSharedUnmanaged(i), ref field9.RefSharedUnmanaged(i), ref field10.RefSharedUnmanaged(i), ref field11.RefSharedUnmanaged(i), ref field12.RefSharedUnmanaged(i), ref field13.RefSharedUnmanaged(i), ref field14.RefSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, ref T14, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSparseUnmanaged(i), ref field1.RefSparseUnmanaged(i), ref field2.RefSparseUnmanaged(i), ref field3.RefSparseUnmanaged(i), ref field4.RefSparseUnmanaged(i), ref field5.RefSparseUnmanaged(i), ref field6.RefSparseUnmanaged(i), ref field7.RefSparseUnmanaged(i), ref field8.RefSparseUnmanaged(i), ref field9.RefSparseUnmanaged(i), ref field10.RefSparseUnmanaged(i), ref field11.RefSparseUnmanaged(i), ref field12.RefSparseUnmanaged(i), ref field13.RefSparseUnmanaged(i), ref field14.RefSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, ref T14, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSparseSharedUnmanaged(i), ref field1.RefSparseSharedUnmanaged(i), ref field2.RefSparseSharedUnmanaged(i), ref field3.RefSparseSharedUnmanaged(i), ref field4.RefSparseSharedUnmanaged(i), ref field5.RefSparseSharedUnmanaged(i), ref field6.RefSparseSharedUnmanaged(i), ref field7.RefSparseSharedUnmanaged(i), ref field8.RefSparseSharedUnmanaged(i), ref field9.RefSparseSharedUnmanaged(i), ref field10.RefSparseSharedUnmanaged(i), ref field11.RefSparseSharedUnmanaged(i), ref field12.RefSparseSharedUnmanaged(i), ref field13.RefSparseSharedUnmanaged(i), ref field14.RefSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, ref T14, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefManaged(i), ref field1.RefManaged(i), ref field2.RefManaged(i), ref field3.RefManaged(i), ref field4.RefManaged(i), ref field5.RefManaged(i), ref field6.RefManaged(i), ref field7.RefManaged(i), ref field8.RefManaged(i), ref field9.RefManaged(i), ref field10.RefManaged(i), ref field11.RefManaged(i), ref field12.RefManaged(i), ref field13.RefManaged(i), ref field14.RefManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, ref T14, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSharedManaged(i), ref field1.RefSharedManaged(i), ref field2.RefSharedManaged(i), ref field3.RefSharedManaged(i), ref field4.RefSharedManaged(i), ref field5.RefSharedManaged(i), ref field6.RefSharedManaged(i), ref field7.RefSharedManaged(i), ref field8.RefSharedManaged(i), ref field9.RefSharedManaged(i), ref field10.RefSharedManaged(i), ref field11.RefSharedManaged(i), ref field12.RefSharedManaged(i), ref field13.RefSharedManaged(i), ref field14.RefSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, ref T14, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSparseManaged(i), ref field1.RefSparseManaged(i), ref field2.RefSparseManaged(i), ref field3.RefSparseManaged(i), ref field4.RefSparseManaged(i), ref field5.RefSparseManaged(i), ref field6.RefSparseManaged(i), ref field7.RefSparseManaged(i), ref field8.RefSparseManaged(i), ref field9.RefSparseManaged(i), ref field10.RefSparseManaged(i), ref field11.RefSparseManaged(i), ref field12.RefSparseManaged(i), ref field13.RefSparseManaged(i), ref field14.RefSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, ref T14, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSparseSharedManaged(i), ref field1.RefSparseSharedManaged(i), ref field2.RefSparseSharedManaged(i), ref field3.RefSparseSharedManaged(i), ref field4.RefSparseSharedManaged(i), ref field5.RefSparseSharedManaged(i), ref field6.RefSparseSharedManaged(i), ref field7.RefSparseSharedManaged(i), ref field8.RefSparseSharedManaged(i), ref field9.RefSparseSharedManaged(i), ref field10.RefSparseSharedManaged(i), ref field11.RefSparseSharedManaged(i), ref field12.RefSparseSharedManaged(i), ref field13.RefSparseSharedManaged(i), ref field14.RefSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 
     /// <summary>
@@ -203,25 +865,135 @@ public static Entity Find<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8); byte* pointer9 = (byte*)it.GetPointer<T9>(9); byte* pointer10 = (byte*)it.GetPointer<T10>(10); byte* pointer11 = (byte*)it.GetPointer<T11>(11); byte* pointer12 = (byte*)it.GetPointer<T12>(12); byte* pointer13 = (byte*)it.GetPointer<T13>(13); byte* pointer14 = (byte*)it.GetPointer<T14>(14);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8); int step9 = it.Step<T9>(9); int step10 = it.Step<T10>(10); int step11 = it.Step<T11>(11); int step12 = it.Step<T12>(12); int step13 = it.Step<T13>(13); int step14 = it.Step<T14>(14);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8); FieldData<T9> field9 = it.GetFieldData<T9>(9); FieldData<T10> field10 = it.GetFieldData<T10>(10); FieldData<T11> field11 = it.GetFieldData<T11>(11); FieldData<T12> field12 = it.GetFieldData<T12>(12); FieldData<T13> field13 = it.GetFieldData<T13>(13); FieldData<T14> field14 = it.GetFieldData<T14>(14);
+        IterationTechnique flags = it.GetIterationTechnique(15);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8], pointer9 = &pointer9[step9], pointer10 = &pointer10[step10], pointer11 = &pointer11[step11], pointer12 = &pointer12[step12], pointer13 = &pointer13[step13], pointer14 = &pointer14[step14])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>() || RuntimeHelpers.IsReferenceOrContainsReferences<T9>() || RuntimeHelpers.IsReferenceOrContainsReferences<T10>() || RuntimeHelpers.IsReferenceOrContainsReferences<T11>() || RuntimeHelpers.IsReferenceOrContainsReferences<T12>() || RuntimeHelpers.IsReferenceOrContainsReferences<T13>() || RuntimeHelpers.IsReferenceOrContainsReferences<T14>())
         {
-            if (!callback((T0*)pointer0, (T1*)pointer1, (T2*)pointer2, (T3*)pointer3, (T4*)pointer4, (T5*)pointer5, (T6*)pointer6, (T7*)pointer7, (T8*)pointer8, (T9*)pointer9, (T10*)pointer10, (T11*)pointer11, (T12*)pointer12, (T13*)pointer13, (T14*)pointer14))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, Ecs.FindPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerUnmanaged(i), field1.PointerUnmanaged(i), field2.PointerUnmanaged(i), field3.PointerUnmanaged(i), field4.PointerUnmanaged(i), field5.PointerUnmanaged(i), field6.PointerUnmanaged(i), field7.PointerUnmanaged(i), field8.PointerUnmanaged(i), field9.PointerUnmanaged(i), field10.PointerUnmanaged(i), field11.PointerUnmanaged(i), field12.PointerUnmanaged(i), field13.PointerUnmanaged(i), field14.PointerUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, Ecs.FindPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSharedUnmanaged(i), field1.PointerSharedUnmanaged(i), field2.PointerSharedUnmanaged(i), field3.PointerSharedUnmanaged(i), field4.PointerSharedUnmanaged(i), field5.PointerSharedUnmanaged(i), field6.PointerSharedUnmanaged(i), field7.PointerSharedUnmanaged(i), field8.PointerSharedUnmanaged(i), field9.PointerSharedUnmanaged(i), field10.PointerSharedUnmanaged(i), field11.PointerSharedUnmanaged(i), field12.PointerSharedUnmanaged(i), field13.PointerSharedUnmanaged(i), field14.PointerSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, Ecs.FindPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSparseUnmanaged(i), field1.PointerSparseUnmanaged(i), field2.PointerSparseUnmanaged(i), field3.PointerSparseUnmanaged(i), field4.PointerSparseUnmanaged(i), field5.PointerSparseUnmanaged(i), field6.PointerSparseUnmanaged(i), field7.PointerSparseUnmanaged(i), field8.PointerSparseUnmanaged(i), field9.PointerSparseUnmanaged(i), field10.PointerSparseUnmanaged(i), field11.PointerSparseUnmanaged(i), field12.PointerSparseUnmanaged(i), field13.PointerSparseUnmanaged(i), field14.PointerSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, Ecs.FindPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSparseSharedUnmanaged(i), field1.PointerSparseSharedUnmanaged(i), field2.PointerSparseSharedUnmanaged(i), field3.PointerSparseSharedUnmanaged(i), field4.PointerSparseSharedUnmanaged(i), field5.PointerSparseSharedUnmanaged(i), field6.PointerSparseSharedUnmanaged(i), field7.PointerSparseSharedUnmanaged(i), field8.PointerSparseSharedUnmanaged(i), field9.PointerSparseSharedUnmanaged(i), field10.PointerSparseSharedUnmanaged(i), field11.PointerSparseSharedUnmanaged(i), field12.PointerSparseSharedUnmanaged(i), field13.PointerSparseSharedUnmanaged(i), field14.PointerSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, Ecs.FindPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerManaged(i), field1.PointerManaged(i), field2.PointerManaged(i), field3.PointerManaged(i), field4.PointerManaged(i), field5.PointerManaged(i), field6.PointerManaged(i), field7.PointerManaged(i), field8.PointerManaged(i), field9.PointerManaged(i), field10.PointerManaged(i), field11.PointerManaged(i), field12.PointerManaged(i), field13.PointerManaged(i), field14.PointerManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, Ecs.FindPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSharedManaged(i), field1.PointerSharedManaged(i), field2.PointerSharedManaged(i), field3.PointerSharedManaged(i), field4.PointerSharedManaged(i), field5.PointerSharedManaged(i), field6.PointerSharedManaged(i), field7.PointerSharedManaged(i), field8.PointerSharedManaged(i), field9.PointerSharedManaged(i), field10.PointerSharedManaged(i), field11.PointerSharedManaged(i), field12.PointerSharedManaged(i), field13.PointerSharedManaged(i), field14.PointerSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, Ecs.FindPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSparseManaged(i), field1.PointerSparseManaged(i), field2.PointerSparseManaged(i), field3.PointerSparseManaged(i), field4.PointerSparseManaged(i), field5.PointerSparseManaged(i), field6.PointerSparseManaged(i), field7.PointerSparseManaged(i), field8.PointerSparseManaged(i), field9.PointerSparseManaged(i), field10.PointerSparseManaged(i), field11.PointerSparseManaged(i), field12.PointerSparseManaged(i), field13.PointerSparseManaged(i), field14.PointerSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, Ecs.FindPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSparseSharedManaged(i), field1.PointerSparseSharedManaged(i), field2.PointerSparseSharedManaged(i), field3.PointerSparseSharedManaged(i), field4.PointerSparseSharedManaged(i), field5.PointerSparseSharedManaged(i), field6.PointerSparseSharedManaged(i), field7.PointerSparseSharedManaged(i), field8.PointerSparseSharedManaged(i), field9.PointerSparseSharedManaged(i), field10.PointerSparseSharedManaged(i), field11.PointerSparseSharedManaged(i), field12.PointerSparseSharedManaged(i), field13.PointerSparseSharedManaged(i), field14.PointerSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 
     /// <summary>
@@ -234,25 +1006,135 @@ public static Entity Find<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
     {
         int count = it.Handle->count; Ecs.Assert(it.Handle->count > 0, "No entities returned, use Iter() or Each() without the entity argument instead.");
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8); byte* pointer9 = (byte*)it.GetPointer<T9>(9); byte* pointer10 = (byte*)it.GetPointer<T10>(10); byte* pointer11 = (byte*)it.GetPointer<T11>(11); byte* pointer12 = (byte*)it.GetPointer<T12>(12); byte* pointer13 = (byte*)it.GetPointer<T13>(13); byte* pointer14 = (byte*)it.GetPointer<T14>(14);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8); int step9 = it.Step<T9>(9); int step10 = it.Step<T10>(10); int step11 = it.Step<T11>(11); int step12 = it.Step<T12>(12); int step13 = it.Step<T13>(13); int step14 = it.Step<T14>(14);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8); FieldData<T9> field9 = it.GetFieldData<T9>(9); FieldData<T10> field10 = it.GetFieldData<T10>(10); FieldData<T11> field11 = it.GetFieldData<T11>(11); FieldData<T12> field12 = it.GetFieldData<T12>(12); FieldData<T13> field13 = it.GetFieldData<T13>(13); FieldData<T14> field14 = it.GetFieldData<T14>(14);
+        IterationTechnique flags = it.GetIterationTechnique(15);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8], pointer9 = &pointer9[step9], pointer10 = &pointer10[step10], pointer11 = &pointer11[step11], pointer12 = &pointer12[step12], pointer13 = &pointer13[step13], pointer14 = &pointer14[step14])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>() || RuntimeHelpers.IsReferenceOrContainsReferences<T9>() || RuntimeHelpers.IsReferenceOrContainsReferences<T10>() || RuntimeHelpers.IsReferenceOrContainsReferences<T11>() || RuntimeHelpers.IsReferenceOrContainsReferences<T12>() || RuntimeHelpers.IsReferenceOrContainsReferences<T13>() || RuntimeHelpers.IsReferenceOrContainsReferences<T14>())
         {
-            if (!callback(new Entity(it.Handle->world, it.Handle->entities[i]), (T0*)pointer0, (T1*)pointer1, (T2*)pointer2, (T3*)pointer3, (T4*)pointer4, (T5*)pointer5, (T6*)pointer6, (T7*)pointer7, (T8*)pointer8, (T9*)pointer9, (T10*)pointer10, (T11*)pointer11, (T12*)pointer12, (T13*)pointer13, (T14*)pointer14))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerUnmanaged(i), field1.PointerUnmanaged(i), field2.PointerUnmanaged(i), field3.PointerUnmanaged(i), field4.PointerUnmanaged(i), field5.PointerUnmanaged(i), field6.PointerUnmanaged(i), field7.PointerUnmanaged(i), field8.PointerUnmanaged(i), field9.PointerUnmanaged(i), field10.PointerUnmanaged(i), field11.PointerUnmanaged(i), field12.PointerUnmanaged(i), field13.PointerUnmanaged(i), field14.PointerUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSharedUnmanaged(i), field1.PointerSharedUnmanaged(i), field2.PointerSharedUnmanaged(i), field3.PointerSharedUnmanaged(i), field4.PointerSharedUnmanaged(i), field5.PointerSharedUnmanaged(i), field6.PointerSharedUnmanaged(i), field7.PointerSharedUnmanaged(i), field8.PointerSharedUnmanaged(i), field9.PointerSharedUnmanaged(i), field10.PointerSharedUnmanaged(i), field11.PointerSharedUnmanaged(i), field12.PointerSharedUnmanaged(i), field13.PointerSharedUnmanaged(i), field14.PointerSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseUnmanaged(i), field1.PointerSparseUnmanaged(i), field2.PointerSparseUnmanaged(i), field3.PointerSparseUnmanaged(i), field4.PointerSparseUnmanaged(i), field5.PointerSparseUnmanaged(i), field6.PointerSparseUnmanaged(i), field7.PointerSparseUnmanaged(i), field8.PointerSparseUnmanaged(i), field9.PointerSparseUnmanaged(i), field10.PointerSparseUnmanaged(i), field11.PointerSparseUnmanaged(i), field12.PointerSparseUnmanaged(i), field13.PointerSparseUnmanaged(i), field14.PointerSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseSharedUnmanaged(i), field1.PointerSparseSharedUnmanaged(i), field2.PointerSparseSharedUnmanaged(i), field3.PointerSparseSharedUnmanaged(i), field4.PointerSparseSharedUnmanaged(i), field5.PointerSparseSharedUnmanaged(i), field6.PointerSparseSharedUnmanaged(i), field7.PointerSparseSharedUnmanaged(i), field8.PointerSparseSharedUnmanaged(i), field9.PointerSparseSharedUnmanaged(i), field10.PointerSparseSharedUnmanaged(i), field11.PointerSparseSharedUnmanaged(i), field12.PointerSparseSharedUnmanaged(i), field13.PointerSparseSharedUnmanaged(i), field14.PointerSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerManaged(i), field1.PointerManaged(i), field2.PointerManaged(i), field3.PointerManaged(i), field4.PointerManaged(i), field5.PointerManaged(i), field6.PointerManaged(i), field7.PointerManaged(i), field8.PointerManaged(i), field9.PointerManaged(i), field10.PointerManaged(i), field11.PointerManaged(i), field12.PointerManaged(i), field13.PointerManaged(i), field14.PointerManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSharedManaged(i), field1.PointerSharedManaged(i), field2.PointerSharedManaged(i), field3.PointerSharedManaged(i), field4.PointerSharedManaged(i), field5.PointerSharedManaged(i), field6.PointerSharedManaged(i), field7.PointerSharedManaged(i), field8.PointerSharedManaged(i), field9.PointerSharedManaged(i), field10.PointerSharedManaged(i), field11.PointerSharedManaged(i), field12.PointerSharedManaged(i), field13.PointerSharedManaged(i), field14.PointerSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseManaged(i), field1.PointerSparseManaged(i), field2.PointerSparseManaged(i), field3.PointerSparseManaged(i), field4.PointerSparseManaged(i), field5.PointerSparseManaged(i), field6.PointerSparseManaged(i), field7.PointerSparseManaged(i), field8.PointerSparseManaged(i), field9.PointerSparseManaged(i), field10.PointerSparseManaged(i), field11.PointerSparseManaged(i), field12.PointerSparseManaged(i), field13.PointerSparseManaged(i), field14.PointerSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseSharedManaged(i), field1.PointerSparseSharedManaged(i), field2.PointerSparseSharedManaged(i), field3.PointerSparseSharedManaged(i), field4.PointerSparseSharedManaged(i), field5.PointerSparseSharedManaged(i), field6.PointerSparseSharedManaged(i), field7.PointerSparseSharedManaged(i), field8.PointerSparseSharedManaged(i), field9.PointerSparseSharedManaged(i), field10.PointerSparseSharedManaged(i), field11.PointerSparseSharedManaged(i), field12.PointerSparseSharedManaged(i), field13.PointerSparseSharedManaged(i), field14.PointerSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 
     /// <summary>
@@ -265,25 +1147,135 @@ public static Entity Find<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8); byte* pointer9 = (byte*)it.GetPointer<T9>(9); byte* pointer10 = (byte*)it.GetPointer<T10>(10); byte* pointer11 = (byte*)it.GetPointer<T11>(11); byte* pointer12 = (byte*)it.GetPointer<T12>(12); byte* pointer13 = (byte*)it.GetPointer<T13>(13); byte* pointer14 = (byte*)it.GetPointer<T14>(14);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8); int step9 = it.Step<T9>(9); int step10 = it.Step<T10>(10); int step11 = it.Step<T11>(11); int step12 = it.Step<T12>(12); int step13 = it.Step<T13>(13); int step14 = it.Step<T14>(14);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8); FieldData<T9> field9 = it.GetFieldData<T9>(9); FieldData<T10> field10 = it.GetFieldData<T10>(10); FieldData<T11> field11 = it.GetFieldData<T11>(11); FieldData<T12> field12 = it.GetFieldData<T12>(12); FieldData<T13> field13 = it.GetFieldData<T13>(13); FieldData<T14> field14 = it.GetFieldData<T14>(14);
+        IterationTechnique flags = it.GetIterationTechnique(15);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8], pointer9 = &pointer9[step9], pointer10 = &pointer10[step10], pointer11 = &pointer11[step11], pointer12 = &pointer12[step12], pointer13 = &pointer13[step13], pointer14 = &pointer14[step14])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>() || RuntimeHelpers.IsReferenceOrContainsReferences<T9>() || RuntimeHelpers.IsReferenceOrContainsReferences<T10>() || RuntimeHelpers.IsReferenceOrContainsReferences<T11>() || RuntimeHelpers.IsReferenceOrContainsReferences<T12>() || RuntimeHelpers.IsReferenceOrContainsReferences<T13>() || RuntimeHelpers.IsReferenceOrContainsReferences<T14>())
         {
-            if (!callback(it, i, (T0*)pointer0, (T1*)pointer1, (T2*)pointer2, (T3*)pointer3, (T4*)pointer4, (T5*)pointer5, (T6*)pointer6, (T7*)pointer7, (T8*)pointer8, (T9*)pointer9, (T10*)pointer10, (T11*)pointer11, (T12*)pointer12, (T13*)pointer13, (T14*)pointer14))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerUnmanaged(i), field1.PointerUnmanaged(i), field2.PointerUnmanaged(i), field3.PointerUnmanaged(i), field4.PointerUnmanaged(i), field5.PointerUnmanaged(i), field6.PointerUnmanaged(i), field7.PointerUnmanaged(i), field8.PointerUnmanaged(i), field9.PointerUnmanaged(i), field10.PointerUnmanaged(i), field11.PointerUnmanaged(i), field12.PointerUnmanaged(i), field13.PointerUnmanaged(i), field14.PointerUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSharedUnmanaged(i), field1.PointerSharedUnmanaged(i), field2.PointerSharedUnmanaged(i), field3.PointerSharedUnmanaged(i), field4.PointerSharedUnmanaged(i), field5.PointerSharedUnmanaged(i), field6.PointerSharedUnmanaged(i), field7.PointerSharedUnmanaged(i), field8.PointerSharedUnmanaged(i), field9.PointerSharedUnmanaged(i), field10.PointerSharedUnmanaged(i), field11.PointerSharedUnmanaged(i), field12.PointerSharedUnmanaged(i), field13.PointerSharedUnmanaged(i), field14.PointerSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSparseUnmanaged(i), field1.PointerSparseUnmanaged(i), field2.PointerSparseUnmanaged(i), field3.PointerSparseUnmanaged(i), field4.PointerSparseUnmanaged(i), field5.PointerSparseUnmanaged(i), field6.PointerSparseUnmanaged(i), field7.PointerSparseUnmanaged(i), field8.PointerSparseUnmanaged(i), field9.PointerSparseUnmanaged(i), field10.PointerSparseUnmanaged(i), field11.PointerSparseUnmanaged(i), field12.PointerSparseUnmanaged(i), field13.PointerSparseUnmanaged(i), field14.PointerSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSparseSharedUnmanaged(i), field1.PointerSparseSharedUnmanaged(i), field2.PointerSparseSharedUnmanaged(i), field3.PointerSparseSharedUnmanaged(i), field4.PointerSparseSharedUnmanaged(i), field5.PointerSparseSharedUnmanaged(i), field6.PointerSparseSharedUnmanaged(i), field7.PointerSparseSharedUnmanaged(i), field8.PointerSparseSharedUnmanaged(i), field9.PointerSparseSharedUnmanaged(i), field10.PointerSparseSharedUnmanaged(i), field11.PointerSparseSharedUnmanaged(i), field12.PointerSparseSharedUnmanaged(i), field13.PointerSparseSharedUnmanaged(i), field14.PointerSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerManaged(i), field1.PointerManaged(i), field2.PointerManaged(i), field3.PointerManaged(i), field4.PointerManaged(i), field5.PointerManaged(i), field6.PointerManaged(i), field7.PointerManaged(i), field8.PointerManaged(i), field9.PointerManaged(i), field10.PointerManaged(i), field11.PointerManaged(i), field12.PointerManaged(i), field13.PointerManaged(i), field14.PointerManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSharedManaged(i), field1.PointerSharedManaged(i), field2.PointerSharedManaged(i), field3.PointerSharedManaged(i), field4.PointerSharedManaged(i), field5.PointerSharedManaged(i), field6.PointerSharedManaged(i), field7.PointerSharedManaged(i), field8.PointerSharedManaged(i), field9.PointerSharedManaged(i), field10.PointerSharedManaged(i), field11.PointerSharedManaged(i), field12.PointerSharedManaged(i), field13.PointerSharedManaged(i), field14.PointerSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSparseManaged(i), field1.PointerSparseManaged(i), field2.PointerSparseManaged(i), field3.PointerSparseManaged(i), field4.PointerSparseManaged(i), field5.PointerSparseManaged(i), field6.PointerSparseManaged(i), field7.PointerSparseManaged(i), field8.PointerSparseManaged(i), field9.PointerSparseManaged(i), field10.PointerSparseManaged(i), field11.PointerSparseManaged(i), field12.PointerSparseManaged(i), field13.PointerSparseManaged(i), field14.PointerSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSparseSharedManaged(i), field1.PointerSparseSharedManaged(i), field2.PointerSparseSharedManaged(i), field3.PointerSparseSharedManaged(i), field4.PointerSparseSharedManaged(i), field5.PointerSparseSharedManaged(i), field6.PointerSparseSharedManaged(i), field7.PointerSparseSharedManaged(i), field8.PointerSparseSharedManaged(i), field9.PointerSparseSharedManaged(i), field10.PointerSparseSharedManaged(i), field11.PointerSparseSharedManaged(i), field12.PointerSparseSharedManaged(i), field13.PointerSparseSharedManaged(i), field14.PointerSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 
     /// <summary>
@@ -296,25 +1288,135 @@ public static Entity Find<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8); byte* pointer9 = (byte*)it.GetPointer<T9>(9); byte* pointer10 = (byte*)it.GetPointer<T10>(10); byte* pointer11 = (byte*)it.GetPointer<T11>(11); byte* pointer12 = (byte*)it.GetPointer<T12>(12); byte* pointer13 = (byte*)it.GetPointer<T13>(13); byte* pointer14 = (byte*)it.GetPointer<T14>(14);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8); int step9 = it.Step<T9>(9); int step10 = it.Step<T10>(10); int step11 = it.Step<T11>(11); int step12 = it.Step<T12>(12); int step13 = it.Step<T13>(13); int step14 = it.Step<T14>(14);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8); FieldData<T9> field9 = it.GetFieldData<T9>(9); FieldData<T10> field10 = it.GetFieldData<T10>(10); FieldData<T11> field11 = it.GetFieldData<T11>(11); FieldData<T12> field12 = it.GetFieldData<T12>(12); FieldData<T13> field13 = it.GetFieldData<T13>(13); FieldData<T14> field14 = it.GetFieldData<T14>(14);
+        IterationTechnique flags = it.GetIterationTechnique(15);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8], pointer9 = &pointer9[step9], pointer10 = &pointer10[step10], pointer11 = &pointer11[step11], pointer12 = &pointer12[step12], pointer13 = &pointer13[step13], pointer14 = &pointer14[step14])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>() || RuntimeHelpers.IsReferenceOrContainsReferences<T9>() || RuntimeHelpers.IsReferenceOrContainsReferences<T10>() || RuntimeHelpers.IsReferenceOrContainsReferences<T11>() || RuntimeHelpers.IsReferenceOrContainsReferences<T12>() || RuntimeHelpers.IsReferenceOrContainsReferences<T13>() || RuntimeHelpers.IsReferenceOrContainsReferences<T14>())
         {
-            if (!callback((T0*)pointer0, (T1*)pointer1, (T2*)pointer2, (T3*)pointer3, (T4*)pointer4, (T5*)pointer5, (T6*)pointer6, (T7*)pointer7, (T8*)pointer8, (T9*)pointer9, (T10*)pointer10, (T11*)pointer11, (T12*)pointer12, (T13*)pointer13, (T14*)pointer14))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, T14*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerUnmanaged(i), field1.PointerUnmanaged(i), field2.PointerUnmanaged(i), field3.PointerUnmanaged(i), field4.PointerUnmanaged(i), field5.PointerUnmanaged(i), field6.PointerUnmanaged(i), field7.PointerUnmanaged(i), field8.PointerUnmanaged(i), field9.PointerUnmanaged(i), field10.PointerUnmanaged(i), field11.PointerUnmanaged(i), field12.PointerUnmanaged(i), field13.PointerUnmanaged(i), field14.PointerUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, T14*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSharedUnmanaged(i), field1.PointerSharedUnmanaged(i), field2.PointerSharedUnmanaged(i), field3.PointerSharedUnmanaged(i), field4.PointerSharedUnmanaged(i), field5.PointerSharedUnmanaged(i), field6.PointerSharedUnmanaged(i), field7.PointerSharedUnmanaged(i), field8.PointerSharedUnmanaged(i), field9.PointerSharedUnmanaged(i), field10.PointerSharedUnmanaged(i), field11.PointerSharedUnmanaged(i), field12.PointerSharedUnmanaged(i), field13.PointerSharedUnmanaged(i), field14.PointerSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, T14*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSparseUnmanaged(i), field1.PointerSparseUnmanaged(i), field2.PointerSparseUnmanaged(i), field3.PointerSparseUnmanaged(i), field4.PointerSparseUnmanaged(i), field5.PointerSparseUnmanaged(i), field6.PointerSparseUnmanaged(i), field7.PointerSparseUnmanaged(i), field8.PointerSparseUnmanaged(i), field9.PointerSparseUnmanaged(i), field10.PointerSparseUnmanaged(i), field11.PointerSparseUnmanaged(i), field12.PointerSparseUnmanaged(i), field13.PointerSparseUnmanaged(i), field14.PointerSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, T14*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSparseSharedUnmanaged(i), field1.PointerSparseSharedUnmanaged(i), field2.PointerSparseSharedUnmanaged(i), field3.PointerSparseSharedUnmanaged(i), field4.PointerSparseSharedUnmanaged(i), field5.PointerSparseSharedUnmanaged(i), field6.PointerSparseSharedUnmanaged(i), field7.PointerSparseSharedUnmanaged(i), field8.PointerSparseSharedUnmanaged(i), field9.PointerSparseSharedUnmanaged(i), field10.PointerSparseSharedUnmanaged(i), field11.PointerSparseSharedUnmanaged(i), field12.PointerSparseSharedUnmanaged(i), field13.PointerSparseSharedUnmanaged(i), field14.PointerSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, T14*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerManaged(i), field1.PointerManaged(i), field2.PointerManaged(i), field3.PointerManaged(i), field4.PointerManaged(i), field5.PointerManaged(i), field6.PointerManaged(i), field7.PointerManaged(i), field8.PointerManaged(i), field9.PointerManaged(i), field10.PointerManaged(i), field11.PointerManaged(i), field12.PointerManaged(i), field13.PointerManaged(i), field14.PointerManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, T14*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSharedManaged(i), field1.PointerSharedManaged(i), field2.PointerSharedManaged(i), field3.PointerSharedManaged(i), field4.PointerSharedManaged(i), field5.PointerSharedManaged(i), field6.PointerSharedManaged(i), field7.PointerSharedManaged(i), field8.PointerSharedManaged(i), field9.PointerSharedManaged(i), field10.PointerSharedManaged(i), field11.PointerSharedManaged(i), field12.PointerSharedManaged(i), field13.PointerSharedManaged(i), field14.PointerSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, T14*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSparseManaged(i), field1.PointerSparseManaged(i), field2.PointerSparseManaged(i), field3.PointerSparseManaged(i), field4.PointerSparseManaged(i), field5.PointerSparseManaged(i), field6.PointerSparseManaged(i), field7.PointerSparseManaged(i), field8.PointerSparseManaged(i), field9.PointerSparseManaged(i), field10.PointerSparseManaged(i), field11.PointerSparseManaged(i), field12.PointerSparseManaged(i), field13.PointerSparseManaged(i), field14.PointerSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, T14*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSparseSharedManaged(i), field1.PointerSparseSharedManaged(i), field2.PointerSparseSharedManaged(i), field3.PointerSparseSharedManaged(i), field4.PointerSparseSharedManaged(i), field5.PointerSparseSharedManaged(i), field6.PointerSparseSharedManaged(i), field7.PointerSparseSharedManaged(i), field8.PointerSparseSharedManaged(i), field9.PointerSparseSharedManaged(i), field10.PointerSparseSharedManaged(i), field11.PointerSparseSharedManaged(i), field12.PointerSparseSharedManaged(i), field13.PointerSparseSharedManaged(i), field14.PointerSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 
     /// <summary>
@@ -327,25 +1429,135 @@ public static Entity Find<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
     {
         int count = it.Handle->count; Ecs.Assert(it.Handle->count > 0, "No entities returned, use Iter() or Each() without the entity argument instead.");
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8); byte* pointer9 = (byte*)it.GetPointer<T9>(9); byte* pointer10 = (byte*)it.GetPointer<T10>(10); byte* pointer11 = (byte*)it.GetPointer<T11>(11); byte* pointer12 = (byte*)it.GetPointer<T12>(12); byte* pointer13 = (byte*)it.GetPointer<T13>(13); byte* pointer14 = (byte*)it.GetPointer<T14>(14);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8); int step9 = it.Step<T9>(9); int step10 = it.Step<T10>(10); int step11 = it.Step<T11>(11); int step12 = it.Step<T12>(12); int step13 = it.Step<T13>(13); int step14 = it.Step<T14>(14);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8); FieldData<T9> field9 = it.GetFieldData<T9>(9); FieldData<T10> field10 = it.GetFieldData<T10>(10); FieldData<T11> field11 = it.GetFieldData<T11>(11); FieldData<T12> field12 = it.GetFieldData<T12>(12); FieldData<T13> field13 = it.GetFieldData<T13>(13); FieldData<T14> field14 = it.GetFieldData<T14>(14);
+        IterationTechnique flags = it.GetIterationTechnique(15);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8], pointer9 = &pointer9[step9], pointer10 = &pointer10[step10], pointer11 = &pointer11[step11], pointer12 = &pointer12[step12], pointer13 = &pointer13[step13], pointer14 = &pointer14[step14])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>() || RuntimeHelpers.IsReferenceOrContainsReferences<T9>() || RuntimeHelpers.IsReferenceOrContainsReferences<T10>() || RuntimeHelpers.IsReferenceOrContainsReferences<T11>() || RuntimeHelpers.IsReferenceOrContainsReferences<T12>() || RuntimeHelpers.IsReferenceOrContainsReferences<T13>() || RuntimeHelpers.IsReferenceOrContainsReferences<T14>())
         {
-            if (!callback(new Entity(it.Handle->world, it.Handle->entities[i]), (T0*)pointer0, (T1*)pointer1, (T2*)pointer2, (T3*)pointer3, (T4*)pointer4, (T5*)pointer5, (T6*)pointer6, (T7*)pointer7, (T8*)pointer8, (T9*)pointer9, (T10*)pointer10, (T11*)pointer11, (T12*)pointer12, (T13*)pointer13, (T14*)pointer14))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, T14*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerUnmanaged(i), field1.PointerUnmanaged(i), field2.PointerUnmanaged(i), field3.PointerUnmanaged(i), field4.PointerUnmanaged(i), field5.PointerUnmanaged(i), field6.PointerUnmanaged(i), field7.PointerUnmanaged(i), field8.PointerUnmanaged(i), field9.PointerUnmanaged(i), field10.PointerUnmanaged(i), field11.PointerUnmanaged(i), field12.PointerUnmanaged(i), field13.PointerUnmanaged(i), field14.PointerUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, T14*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSharedUnmanaged(i), field1.PointerSharedUnmanaged(i), field2.PointerSharedUnmanaged(i), field3.PointerSharedUnmanaged(i), field4.PointerSharedUnmanaged(i), field5.PointerSharedUnmanaged(i), field6.PointerSharedUnmanaged(i), field7.PointerSharedUnmanaged(i), field8.PointerSharedUnmanaged(i), field9.PointerSharedUnmanaged(i), field10.PointerSharedUnmanaged(i), field11.PointerSharedUnmanaged(i), field12.PointerSharedUnmanaged(i), field13.PointerSharedUnmanaged(i), field14.PointerSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, T14*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseUnmanaged(i), field1.PointerSparseUnmanaged(i), field2.PointerSparseUnmanaged(i), field3.PointerSparseUnmanaged(i), field4.PointerSparseUnmanaged(i), field5.PointerSparseUnmanaged(i), field6.PointerSparseUnmanaged(i), field7.PointerSparseUnmanaged(i), field8.PointerSparseUnmanaged(i), field9.PointerSparseUnmanaged(i), field10.PointerSparseUnmanaged(i), field11.PointerSparseUnmanaged(i), field12.PointerSparseUnmanaged(i), field13.PointerSparseUnmanaged(i), field14.PointerSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, T14*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseSharedUnmanaged(i), field1.PointerSparseSharedUnmanaged(i), field2.PointerSparseSharedUnmanaged(i), field3.PointerSparseSharedUnmanaged(i), field4.PointerSparseSharedUnmanaged(i), field5.PointerSparseSharedUnmanaged(i), field6.PointerSparseSharedUnmanaged(i), field7.PointerSparseSharedUnmanaged(i), field8.PointerSparseSharedUnmanaged(i), field9.PointerSparseSharedUnmanaged(i), field10.PointerSparseSharedUnmanaged(i), field11.PointerSparseSharedUnmanaged(i), field12.PointerSparseSharedUnmanaged(i), field13.PointerSparseSharedUnmanaged(i), field14.PointerSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, T14*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerManaged(i), field1.PointerManaged(i), field2.PointerManaged(i), field3.PointerManaged(i), field4.PointerManaged(i), field5.PointerManaged(i), field6.PointerManaged(i), field7.PointerManaged(i), field8.PointerManaged(i), field9.PointerManaged(i), field10.PointerManaged(i), field11.PointerManaged(i), field12.PointerManaged(i), field13.PointerManaged(i), field14.PointerManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, T14*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSharedManaged(i), field1.PointerSharedManaged(i), field2.PointerSharedManaged(i), field3.PointerSharedManaged(i), field4.PointerSharedManaged(i), field5.PointerSharedManaged(i), field6.PointerSharedManaged(i), field7.PointerSharedManaged(i), field8.PointerSharedManaged(i), field9.PointerSharedManaged(i), field10.PointerSharedManaged(i), field11.PointerSharedManaged(i), field12.PointerSharedManaged(i), field13.PointerSharedManaged(i), field14.PointerSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, T14*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseManaged(i), field1.PointerSparseManaged(i), field2.PointerSparseManaged(i), field3.PointerSparseManaged(i), field4.PointerSparseManaged(i), field5.PointerSparseManaged(i), field6.PointerSparseManaged(i), field7.PointerSparseManaged(i), field8.PointerSparseManaged(i), field9.PointerSparseManaged(i), field10.PointerSparseManaged(i), field11.PointerSparseManaged(i), field12.PointerSparseManaged(i), field13.PointerSparseManaged(i), field14.PointerSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, T14*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseSharedManaged(i), field1.PointerSparseSharedManaged(i), field2.PointerSparseSharedManaged(i), field3.PointerSparseSharedManaged(i), field4.PointerSparseSharedManaged(i), field5.PointerSparseSharedManaged(i), field6.PointerSparseSharedManaged(i), field7.PointerSparseSharedManaged(i), field8.PointerSparseSharedManaged(i), field9.PointerSparseSharedManaged(i), field10.PointerSparseSharedManaged(i), field11.PointerSparseSharedManaged(i), field12.PointerSparseSharedManaged(i), field13.PointerSparseSharedManaged(i), field14.PointerSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 
     /// <summary>
@@ -358,24 +1570,134 @@ public static Entity Find<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8); byte* pointer9 = (byte*)it.GetPointer<T9>(9); byte* pointer10 = (byte*)it.GetPointer<T10>(10); byte* pointer11 = (byte*)it.GetPointer<T11>(11); byte* pointer12 = (byte*)it.GetPointer<T12>(12); byte* pointer13 = (byte*)it.GetPointer<T13>(13); byte* pointer14 = (byte*)it.GetPointer<T14>(14);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8); int step9 = it.Step<T9>(9); int step10 = it.Step<T10>(10); int step11 = it.Step<T11>(11); int step12 = it.Step<T12>(12); int step13 = it.Step<T13>(13); int step14 = it.Step<T14>(14);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8); FieldData<T9> field9 = it.GetFieldData<T9>(9); FieldData<T10> field10 = it.GetFieldData<T10>(10); FieldData<T11> field11 = it.GetFieldData<T11>(11); FieldData<T12> field12 = it.GetFieldData<T12>(12); FieldData<T13> field13 = it.GetFieldData<T13>(13); FieldData<T14> field14 = it.GetFieldData<T14>(14);
+        IterationTechnique flags = it.GetIterationTechnique(15);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8], pointer9 = &pointer9[step9], pointer10 = &pointer10[step10], pointer11 = &pointer11[step11], pointer12 = &pointer12[step12], pointer13 = &pointer13[step13], pointer14 = &pointer14[step14])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>() || RuntimeHelpers.IsReferenceOrContainsReferences<T9>() || RuntimeHelpers.IsReferenceOrContainsReferences<T10>() || RuntimeHelpers.IsReferenceOrContainsReferences<T11>() || RuntimeHelpers.IsReferenceOrContainsReferences<T12>() || RuntimeHelpers.IsReferenceOrContainsReferences<T13>() || RuntimeHelpers.IsReferenceOrContainsReferences<T14>())
         {
-            if (!callback(it, i, (T0*)pointer0, (T1*)pointer1, (T2*)pointer2, (T3*)pointer3, (T4*)pointer4, (T5*)pointer5, (T6*)pointer6, (T7*)pointer7, (T8*)pointer8, (T9*)pointer9, (T10*)pointer10, (T11*)pointer11, (T12*)pointer12, (T13*)pointer13, (T14*)pointer14))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, T14*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerUnmanaged(i), field1.PointerUnmanaged(i), field2.PointerUnmanaged(i), field3.PointerUnmanaged(i), field4.PointerUnmanaged(i), field5.PointerUnmanaged(i), field6.PointerUnmanaged(i), field7.PointerUnmanaged(i), field8.PointerUnmanaged(i), field9.PointerUnmanaged(i), field10.PointerUnmanaged(i), field11.PointerUnmanaged(i), field12.PointerUnmanaged(i), field13.PointerUnmanaged(i), field14.PointerUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, T14*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSharedUnmanaged(i), field1.PointerSharedUnmanaged(i), field2.PointerSharedUnmanaged(i), field3.PointerSharedUnmanaged(i), field4.PointerSharedUnmanaged(i), field5.PointerSharedUnmanaged(i), field6.PointerSharedUnmanaged(i), field7.PointerSharedUnmanaged(i), field8.PointerSharedUnmanaged(i), field9.PointerSharedUnmanaged(i), field10.PointerSharedUnmanaged(i), field11.PointerSharedUnmanaged(i), field12.PointerSharedUnmanaged(i), field13.PointerSharedUnmanaged(i), field14.PointerSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, T14*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSparseUnmanaged(i), field1.PointerSparseUnmanaged(i), field2.PointerSparseUnmanaged(i), field3.PointerSparseUnmanaged(i), field4.PointerSparseUnmanaged(i), field5.PointerSparseUnmanaged(i), field6.PointerSparseUnmanaged(i), field7.PointerSparseUnmanaged(i), field8.PointerSparseUnmanaged(i), field9.PointerSparseUnmanaged(i), field10.PointerSparseUnmanaged(i), field11.PointerSparseUnmanaged(i), field12.PointerSparseUnmanaged(i), field13.PointerSparseUnmanaged(i), field14.PointerSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, T14*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSparseSharedUnmanaged(i), field1.PointerSparseSharedUnmanaged(i), field2.PointerSparseSharedUnmanaged(i), field3.PointerSparseSharedUnmanaged(i), field4.PointerSparseSharedUnmanaged(i), field5.PointerSparseSharedUnmanaged(i), field6.PointerSparseSharedUnmanaged(i), field7.PointerSparseSharedUnmanaged(i), field8.PointerSparseSharedUnmanaged(i), field9.PointerSparseSharedUnmanaged(i), field10.PointerSparseSharedUnmanaged(i), field11.PointerSparseSharedUnmanaged(i), field12.PointerSparseSharedUnmanaged(i), field13.PointerSparseSharedUnmanaged(i), field14.PointerSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, T14*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerManaged(i), field1.PointerManaged(i), field2.PointerManaged(i), field3.PointerManaged(i), field4.PointerManaged(i), field5.PointerManaged(i), field6.PointerManaged(i), field7.PointerManaged(i), field8.PointerManaged(i), field9.PointerManaged(i), field10.PointerManaged(i), field11.PointerManaged(i), field12.PointerManaged(i), field13.PointerManaged(i), field14.PointerManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, T14*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSharedManaged(i), field1.PointerSharedManaged(i), field2.PointerSharedManaged(i), field3.PointerSharedManaged(i), field4.PointerSharedManaged(i), field5.PointerSharedManaged(i), field6.PointerSharedManaged(i), field7.PointerSharedManaged(i), field8.PointerSharedManaged(i), field9.PointerSharedManaged(i), field10.PointerSharedManaged(i), field11.PointerSharedManaged(i), field12.PointerSharedManaged(i), field13.PointerSharedManaged(i), field14.PointerSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, T14*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSparseManaged(i), field1.PointerSparseManaged(i), field2.PointerSparseManaged(i), field3.PointerSparseManaged(i), field4.PointerSparseManaged(i), field5.PointerSparseManaged(i), field6.PointerSparseManaged(i), field7.PointerSparseManaged(i), field8.PointerSparseManaged(i), field9.PointerSparseManaged(i), field10.PointerSparseManaged(i), field11.PointerSparseManaged(i), field12.PointerSparseManaged(i), field13.PointerSparseManaged(i), field14.PointerSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, T14*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSparseSharedManaged(i), field1.PointerSparseSharedManaged(i), field2.PointerSparseSharedManaged(i), field3.PointerSparseSharedManaged(i), field4.PointerSparseSharedManaged(i), field5.PointerSparseSharedManaged(i), field6.PointerSparseSharedManaged(i), field7.PointerSparseSharedManaged(i), field8.PointerSparseSharedManaged(i), field9.PointerSparseSharedManaged(i), field10.PointerSparseSharedManaged(i), field11.PointerSparseSharedManaged(i), field12.PointerSparseSharedManaged(i), field13.PointerSparseSharedManaged(i), field14.PointerSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 }
\ No newline at end of file
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/Invoker/Find/Iterator/T16.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/Invoker/Find/Iterator/T16.g.cs
index 77f0d473..afc649be 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/Invoker/Find/Iterator/T16.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/Invoker/Find/Iterator/T16.g.cs
@@ -1,5 +1,7 @@
 // Find/Iterator/T16.g.cs
 // File was auto-generated by /_/src/Flecs.NET.Codegen/Generators/Invoker.cs
+using System;
+using System.Runtime.CompilerServices;
 using Flecs.NET.Utilities;
 using static Flecs.NET.Bindings.flecs;
 
@@ -17,25 +19,135 @@ public static Entity Find<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8); byte* pointer9 = (byte*)it.GetPointer<T9>(9); byte* pointer10 = (byte*)it.GetPointer<T10>(10); byte* pointer11 = (byte*)it.GetPointer<T11>(11); byte* pointer12 = (byte*)it.GetPointer<T12>(12); byte* pointer13 = (byte*)it.GetPointer<T13>(13); byte* pointer14 = (byte*)it.GetPointer<T14>(14); byte* pointer15 = (byte*)it.GetPointer<T15>(15);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8); int step9 = it.Step<T9>(9); int step10 = it.Step<T10>(10); int step11 = it.Step<T11>(11); int step12 = it.Step<T12>(12); int step13 = it.Step<T13>(13); int step14 = it.Step<T14>(14); int step15 = it.Step<T15>(15);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8); FieldData<T9> field9 = it.GetFieldData<T9>(9); FieldData<T10> field10 = it.GetFieldData<T10>(10); FieldData<T11> field11 = it.GetFieldData<T11>(11); FieldData<T12> field12 = it.GetFieldData<T12>(12); FieldData<T13> field13 = it.GetFieldData<T13>(13); FieldData<T14> field14 = it.GetFieldData<T14>(14); FieldData<T15> field15 = it.GetFieldData<T15>(15);
+        IterationTechnique flags = it.GetIterationTechnique(16);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8], pointer9 = &pointer9[step9], pointer10 = &pointer10[step10], pointer11 = &pointer11[step11], pointer12 = &pointer12[step12], pointer13 = &pointer13[step13], pointer14 = &pointer14[step14], pointer15 = &pointer15[step15])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>() || RuntimeHelpers.IsReferenceOrContainsReferences<T9>() || RuntimeHelpers.IsReferenceOrContainsReferences<T10>() || RuntimeHelpers.IsReferenceOrContainsReferences<T11>() || RuntimeHelpers.IsReferenceOrContainsReferences<T12>() || RuntimeHelpers.IsReferenceOrContainsReferences<T13>() || RuntimeHelpers.IsReferenceOrContainsReferences<T14>() || RuntimeHelpers.IsReferenceOrContainsReferences<T15>())
         {
-            if (!callback(ref Managed.GetTypeRef<T0>(pointer0), ref Managed.GetTypeRef<T1>(pointer1), ref Managed.GetTypeRef<T2>(pointer2), ref Managed.GetTypeRef<T3>(pointer3), ref Managed.GetTypeRef<T4>(pointer4), ref Managed.GetTypeRef<T5>(pointer5), ref Managed.GetTypeRef<T6>(pointer6), ref Managed.GetTypeRef<T7>(pointer7), ref Managed.GetTypeRef<T8>(pointer8), ref Managed.GetTypeRef<T9>(pointer9), ref Managed.GetTypeRef<T10>(pointer10), ref Managed.GetTypeRef<T11>(pointer11), ref Managed.GetTypeRef<T12>(pointer12), ref Managed.GetTypeRef<T13>(pointer13), ref Managed.GetTypeRef<T14>(pointer14), ref Managed.GetTypeRef<T15>(pointer15)))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, Ecs.FindRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefUnmanaged(i), ref field1.RefUnmanaged(i), ref field2.RefUnmanaged(i), ref field3.RefUnmanaged(i), ref field4.RefUnmanaged(i), ref field5.RefUnmanaged(i), ref field6.RefUnmanaged(i), ref field7.RefUnmanaged(i), ref field8.RefUnmanaged(i), ref field9.RefUnmanaged(i), ref field10.RefUnmanaged(i), ref field11.RefUnmanaged(i), ref field12.RefUnmanaged(i), ref field13.RefUnmanaged(i), ref field14.RefUnmanaged(i), ref field15.RefUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, Ecs.FindRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSharedUnmanaged(i), ref field1.RefSharedUnmanaged(i), ref field2.RefSharedUnmanaged(i), ref field3.RefSharedUnmanaged(i), ref field4.RefSharedUnmanaged(i), ref field5.RefSharedUnmanaged(i), ref field6.RefSharedUnmanaged(i), ref field7.RefSharedUnmanaged(i), ref field8.RefSharedUnmanaged(i), ref field9.RefSharedUnmanaged(i), ref field10.RefSharedUnmanaged(i), ref field11.RefSharedUnmanaged(i), ref field12.RefSharedUnmanaged(i), ref field13.RefSharedUnmanaged(i), ref field14.RefSharedUnmanaged(i), ref field15.RefSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, Ecs.FindRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSparseUnmanaged(i), ref field1.RefSparseUnmanaged(i), ref field2.RefSparseUnmanaged(i), ref field3.RefSparseUnmanaged(i), ref field4.RefSparseUnmanaged(i), ref field5.RefSparseUnmanaged(i), ref field6.RefSparseUnmanaged(i), ref field7.RefSparseUnmanaged(i), ref field8.RefSparseUnmanaged(i), ref field9.RefSparseUnmanaged(i), ref field10.RefSparseUnmanaged(i), ref field11.RefSparseUnmanaged(i), ref field12.RefSparseUnmanaged(i), ref field13.RefSparseUnmanaged(i), ref field14.RefSparseUnmanaged(i), ref field15.RefSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, Ecs.FindRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSparseSharedUnmanaged(i), ref field1.RefSparseSharedUnmanaged(i), ref field2.RefSparseSharedUnmanaged(i), ref field3.RefSparseSharedUnmanaged(i), ref field4.RefSparseSharedUnmanaged(i), ref field5.RefSparseSharedUnmanaged(i), ref field6.RefSparseSharedUnmanaged(i), ref field7.RefSparseSharedUnmanaged(i), ref field8.RefSparseSharedUnmanaged(i), ref field9.RefSparseSharedUnmanaged(i), ref field10.RefSparseSharedUnmanaged(i), ref field11.RefSparseSharedUnmanaged(i), ref field12.RefSparseSharedUnmanaged(i), ref field13.RefSparseSharedUnmanaged(i), ref field14.RefSparseSharedUnmanaged(i), ref field15.RefSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, Ecs.FindRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefManaged(i), ref field1.RefManaged(i), ref field2.RefManaged(i), ref field3.RefManaged(i), ref field4.RefManaged(i), ref field5.RefManaged(i), ref field6.RefManaged(i), ref field7.RefManaged(i), ref field8.RefManaged(i), ref field9.RefManaged(i), ref field10.RefManaged(i), ref field11.RefManaged(i), ref field12.RefManaged(i), ref field13.RefManaged(i), ref field14.RefManaged(i), ref field15.RefManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, Ecs.FindRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSharedManaged(i), ref field1.RefSharedManaged(i), ref field2.RefSharedManaged(i), ref field3.RefSharedManaged(i), ref field4.RefSharedManaged(i), ref field5.RefSharedManaged(i), ref field6.RefSharedManaged(i), ref field7.RefSharedManaged(i), ref field8.RefSharedManaged(i), ref field9.RefSharedManaged(i), ref field10.RefSharedManaged(i), ref field11.RefSharedManaged(i), ref field12.RefSharedManaged(i), ref field13.RefSharedManaged(i), ref field14.RefSharedManaged(i), ref field15.RefSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, Ecs.FindRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSparseManaged(i), ref field1.RefSparseManaged(i), ref field2.RefSparseManaged(i), ref field3.RefSparseManaged(i), ref field4.RefSparseManaged(i), ref field5.RefSparseManaged(i), ref field6.RefSparseManaged(i), ref field7.RefSparseManaged(i), ref field8.RefSparseManaged(i), ref field9.RefSparseManaged(i), ref field10.RefSparseManaged(i), ref field11.RefSparseManaged(i), ref field12.RefSparseManaged(i), ref field13.RefSparseManaged(i), ref field14.RefSparseManaged(i), ref field15.RefSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, Ecs.FindRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSparseSharedManaged(i), ref field1.RefSparseSharedManaged(i), ref field2.RefSparseSharedManaged(i), ref field3.RefSparseSharedManaged(i), ref field4.RefSparseSharedManaged(i), ref field5.RefSparseSharedManaged(i), ref field6.RefSparseSharedManaged(i), ref field7.RefSparseSharedManaged(i), ref field8.RefSparseSharedManaged(i), ref field9.RefSparseSharedManaged(i), ref field10.RefSparseSharedManaged(i), ref field11.RefSparseSharedManaged(i), ref field12.RefSparseSharedManaged(i), ref field13.RefSparseSharedManaged(i), ref field14.RefSparseSharedManaged(i), ref field15.RefSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 
     /// <summary>
@@ -48,25 +160,135 @@ public static Entity Find<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
     {
         int count = it.Handle->count; Ecs.Assert(it.Handle->count > 0, "No entities returned, use Iter() or Each() without the entity argument instead.");
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8); byte* pointer9 = (byte*)it.GetPointer<T9>(9); byte* pointer10 = (byte*)it.GetPointer<T10>(10); byte* pointer11 = (byte*)it.GetPointer<T11>(11); byte* pointer12 = (byte*)it.GetPointer<T12>(12); byte* pointer13 = (byte*)it.GetPointer<T13>(13); byte* pointer14 = (byte*)it.GetPointer<T14>(14); byte* pointer15 = (byte*)it.GetPointer<T15>(15);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8); int step9 = it.Step<T9>(9); int step10 = it.Step<T10>(10); int step11 = it.Step<T11>(11); int step12 = it.Step<T12>(12); int step13 = it.Step<T13>(13); int step14 = it.Step<T14>(14); int step15 = it.Step<T15>(15);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8); FieldData<T9> field9 = it.GetFieldData<T9>(9); FieldData<T10> field10 = it.GetFieldData<T10>(10); FieldData<T11> field11 = it.GetFieldData<T11>(11); FieldData<T12> field12 = it.GetFieldData<T12>(12); FieldData<T13> field13 = it.GetFieldData<T13>(13); FieldData<T14> field14 = it.GetFieldData<T14>(14); FieldData<T15> field15 = it.GetFieldData<T15>(15);
+        IterationTechnique flags = it.GetIterationTechnique(16);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8], pointer9 = &pointer9[step9], pointer10 = &pointer10[step10], pointer11 = &pointer11[step11], pointer12 = &pointer12[step12], pointer13 = &pointer13[step13], pointer14 = &pointer14[step14], pointer15 = &pointer15[step15])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>() || RuntimeHelpers.IsReferenceOrContainsReferences<T9>() || RuntimeHelpers.IsReferenceOrContainsReferences<T10>() || RuntimeHelpers.IsReferenceOrContainsReferences<T11>() || RuntimeHelpers.IsReferenceOrContainsReferences<T12>() || RuntimeHelpers.IsReferenceOrContainsReferences<T13>() || RuntimeHelpers.IsReferenceOrContainsReferences<T14>() || RuntimeHelpers.IsReferenceOrContainsReferences<T15>())
         {
-            if (!callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref Managed.GetTypeRef<T0>(pointer0), ref Managed.GetTypeRef<T1>(pointer1), ref Managed.GetTypeRef<T2>(pointer2), ref Managed.GetTypeRef<T3>(pointer3), ref Managed.GetTypeRef<T4>(pointer4), ref Managed.GetTypeRef<T5>(pointer5), ref Managed.GetTypeRef<T6>(pointer6), ref Managed.GetTypeRef<T7>(pointer7), ref Managed.GetTypeRef<T8>(pointer8), ref Managed.GetTypeRef<T9>(pointer9), ref Managed.GetTypeRef<T10>(pointer10), ref Managed.GetTypeRef<T11>(pointer11), ref Managed.GetTypeRef<T12>(pointer12), ref Managed.GetTypeRef<T13>(pointer13), ref Managed.GetTypeRef<T14>(pointer14), ref Managed.GetTypeRef<T15>(pointer15)))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefUnmanaged(i), ref field1.RefUnmanaged(i), ref field2.RefUnmanaged(i), ref field3.RefUnmanaged(i), ref field4.RefUnmanaged(i), ref field5.RefUnmanaged(i), ref field6.RefUnmanaged(i), ref field7.RefUnmanaged(i), ref field8.RefUnmanaged(i), ref field9.RefUnmanaged(i), ref field10.RefUnmanaged(i), ref field11.RefUnmanaged(i), ref field12.RefUnmanaged(i), ref field13.RefUnmanaged(i), ref field14.RefUnmanaged(i), ref field15.RefUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSharedUnmanaged(i), ref field1.RefSharedUnmanaged(i), ref field2.RefSharedUnmanaged(i), ref field3.RefSharedUnmanaged(i), ref field4.RefSharedUnmanaged(i), ref field5.RefSharedUnmanaged(i), ref field6.RefSharedUnmanaged(i), ref field7.RefSharedUnmanaged(i), ref field8.RefSharedUnmanaged(i), ref field9.RefSharedUnmanaged(i), ref field10.RefSharedUnmanaged(i), ref field11.RefSharedUnmanaged(i), ref field12.RefSharedUnmanaged(i), ref field13.RefSharedUnmanaged(i), ref field14.RefSharedUnmanaged(i), ref field15.RefSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseUnmanaged(i), ref field1.RefSparseUnmanaged(i), ref field2.RefSparseUnmanaged(i), ref field3.RefSparseUnmanaged(i), ref field4.RefSparseUnmanaged(i), ref field5.RefSparseUnmanaged(i), ref field6.RefSparseUnmanaged(i), ref field7.RefSparseUnmanaged(i), ref field8.RefSparseUnmanaged(i), ref field9.RefSparseUnmanaged(i), ref field10.RefSparseUnmanaged(i), ref field11.RefSparseUnmanaged(i), ref field12.RefSparseUnmanaged(i), ref field13.RefSparseUnmanaged(i), ref field14.RefSparseUnmanaged(i), ref field15.RefSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseSharedUnmanaged(i), ref field1.RefSparseSharedUnmanaged(i), ref field2.RefSparseSharedUnmanaged(i), ref field3.RefSparseSharedUnmanaged(i), ref field4.RefSparseSharedUnmanaged(i), ref field5.RefSparseSharedUnmanaged(i), ref field6.RefSparseSharedUnmanaged(i), ref field7.RefSparseSharedUnmanaged(i), ref field8.RefSparseSharedUnmanaged(i), ref field9.RefSparseSharedUnmanaged(i), ref field10.RefSparseSharedUnmanaged(i), ref field11.RefSparseSharedUnmanaged(i), ref field12.RefSparseSharedUnmanaged(i), ref field13.RefSparseSharedUnmanaged(i), ref field14.RefSparseSharedUnmanaged(i), ref field15.RefSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefManaged(i), ref field1.RefManaged(i), ref field2.RefManaged(i), ref field3.RefManaged(i), ref field4.RefManaged(i), ref field5.RefManaged(i), ref field6.RefManaged(i), ref field7.RefManaged(i), ref field8.RefManaged(i), ref field9.RefManaged(i), ref field10.RefManaged(i), ref field11.RefManaged(i), ref field12.RefManaged(i), ref field13.RefManaged(i), ref field14.RefManaged(i), ref field15.RefManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSharedManaged(i), ref field1.RefSharedManaged(i), ref field2.RefSharedManaged(i), ref field3.RefSharedManaged(i), ref field4.RefSharedManaged(i), ref field5.RefSharedManaged(i), ref field6.RefSharedManaged(i), ref field7.RefSharedManaged(i), ref field8.RefSharedManaged(i), ref field9.RefSharedManaged(i), ref field10.RefSharedManaged(i), ref field11.RefSharedManaged(i), ref field12.RefSharedManaged(i), ref field13.RefSharedManaged(i), ref field14.RefSharedManaged(i), ref field15.RefSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseManaged(i), ref field1.RefSparseManaged(i), ref field2.RefSparseManaged(i), ref field3.RefSparseManaged(i), ref field4.RefSparseManaged(i), ref field5.RefSparseManaged(i), ref field6.RefSparseManaged(i), ref field7.RefSparseManaged(i), ref field8.RefSparseManaged(i), ref field9.RefSparseManaged(i), ref field10.RefSparseManaged(i), ref field11.RefSparseManaged(i), ref field12.RefSparseManaged(i), ref field13.RefSparseManaged(i), ref field14.RefSparseManaged(i), ref field15.RefSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseSharedManaged(i), ref field1.RefSparseSharedManaged(i), ref field2.RefSparseSharedManaged(i), ref field3.RefSparseSharedManaged(i), ref field4.RefSparseSharedManaged(i), ref field5.RefSparseSharedManaged(i), ref field6.RefSparseSharedManaged(i), ref field7.RefSparseSharedManaged(i), ref field8.RefSparseSharedManaged(i), ref field9.RefSparseSharedManaged(i), ref field10.RefSparseSharedManaged(i), ref field11.RefSparseSharedManaged(i), ref field12.RefSparseSharedManaged(i), ref field13.RefSparseSharedManaged(i), ref field14.RefSparseSharedManaged(i), ref field15.RefSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 
     /// <summary>
@@ -79,25 +301,135 @@ public static Entity Find<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8); byte* pointer9 = (byte*)it.GetPointer<T9>(9); byte* pointer10 = (byte*)it.GetPointer<T10>(10); byte* pointer11 = (byte*)it.GetPointer<T11>(11); byte* pointer12 = (byte*)it.GetPointer<T12>(12); byte* pointer13 = (byte*)it.GetPointer<T13>(13); byte* pointer14 = (byte*)it.GetPointer<T14>(14); byte* pointer15 = (byte*)it.GetPointer<T15>(15);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8); int step9 = it.Step<T9>(9); int step10 = it.Step<T10>(10); int step11 = it.Step<T11>(11); int step12 = it.Step<T12>(12); int step13 = it.Step<T13>(13); int step14 = it.Step<T14>(14); int step15 = it.Step<T15>(15);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8); FieldData<T9> field9 = it.GetFieldData<T9>(9); FieldData<T10> field10 = it.GetFieldData<T10>(10); FieldData<T11> field11 = it.GetFieldData<T11>(11); FieldData<T12> field12 = it.GetFieldData<T12>(12); FieldData<T13> field13 = it.GetFieldData<T13>(13); FieldData<T14> field14 = it.GetFieldData<T14>(14); FieldData<T15> field15 = it.GetFieldData<T15>(15);
+        IterationTechnique flags = it.GetIterationTechnique(16);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8], pointer9 = &pointer9[step9], pointer10 = &pointer10[step10], pointer11 = &pointer11[step11], pointer12 = &pointer12[step12], pointer13 = &pointer13[step13], pointer14 = &pointer14[step14], pointer15 = &pointer15[step15])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>() || RuntimeHelpers.IsReferenceOrContainsReferences<T9>() || RuntimeHelpers.IsReferenceOrContainsReferences<T10>() || RuntimeHelpers.IsReferenceOrContainsReferences<T11>() || RuntimeHelpers.IsReferenceOrContainsReferences<T12>() || RuntimeHelpers.IsReferenceOrContainsReferences<T13>() || RuntimeHelpers.IsReferenceOrContainsReferences<T14>() || RuntimeHelpers.IsReferenceOrContainsReferences<T15>())
         {
-            if (!callback(it, i, ref Managed.GetTypeRef<T0>(pointer0), ref Managed.GetTypeRef<T1>(pointer1), ref Managed.GetTypeRef<T2>(pointer2), ref Managed.GetTypeRef<T3>(pointer3), ref Managed.GetTypeRef<T4>(pointer4), ref Managed.GetTypeRef<T5>(pointer5), ref Managed.GetTypeRef<T6>(pointer6), ref Managed.GetTypeRef<T7>(pointer7), ref Managed.GetTypeRef<T8>(pointer8), ref Managed.GetTypeRef<T9>(pointer9), ref Managed.GetTypeRef<T10>(pointer10), ref Managed.GetTypeRef<T11>(pointer11), ref Managed.GetTypeRef<T12>(pointer12), ref Managed.GetTypeRef<T13>(pointer13), ref Managed.GetTypeRef<T14>(pointer14), ref Managed.GetTypeRef<T15>(pointer15)))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, Ecs.FindIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefUnmanaged(i), ref field1.RefUnmanaged(i), ref field2.RefUnmanaged(i), ref field3.RefUnmanaged(i), ref field4.RefUnmanaged(i), ref field5.RefUnmanaged(i), ref field6.RefUnmanaged(i), ref field7.RefUnmanaged(i), ref field8.RefUnmanaged(i), ref field9.RefUnmanaged(i), ref field10.RefUnmanaged(i), ref field11.RefUnmanaged(i), ref field12.RefUnmanaged(i), ref field13.RefUnmanaged(i), ref field14.RefUnmanaged(i), ref field15.RefUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, Ecs.FindIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSharedUnmanaged(i), ref field1.RefSharedUnmanaged(i), ref field2.RefSharedUnmanaged(i), ref field3.RefSharedUnmanaged(i), ref field4.RefSharedUnmanaged(i), ref field5.RefSharedUnmanaged(i), ref field6.RefSharedUnmanaged(i), ref field7.RefSharedUnmanaged(i), ref field8.RefSharedUnmanaged(i), ref field9.RefSharedUnmanaged(i), ref field10.RefSharedUnmanaged(i), ref field11.RefSharedUnmanaged(i), ref field12.RefSharedUnmanaged(i), ref field13.RefSharedUnmanaged(i), ref field14.RefSharedUnmanaged(i), ref field15.RefSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, Ecs.FindIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSparseUnmanaged(i), ref field1.RefSparseUnmanaged(i), ref field2.RefSparseUnmanaged(i), ref field3.RefSparseUnmanaged(i), ref field4.RefSparseUnmanaged(i), ref field5.RefSparseUnmanaged(i), ref field6.RefSparseUnmanaged(i), ref field7.RefSparseUnmanaged(i), ref field8.RefSparseUnmanaged(i), ref field9.RefSparseUnmanaged(i), ref field10.RefSparseUnmanaged(i), ref field11.RefSparseUnmanaged(i), ref field12.RefSparseUnmanaged(i), ref field13.RefSparseUnmanaged(i), ref field14.RefSparseUnmanaged(i), ref field15.RefSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, Ecs.FindIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSparseSharedUnmanaged(i), ref field1.RefSparseSharedUnmanaged(i), ref field2.RefSparseSharedUnmanaged(i), ref field3.RefSparseSharedUnmanaged(i), ref field4.RefSparseSharedUnmanaged(i), ref field5.RefSparseSharedUnmanaged(i), ref field6.RefSparseSharedUnmanaged(i), ref field7.RefSparseSharedUnmanaged(i), ref field8.RefSparseSharedUnmanaged(i), ref field9.RefSparseSharedUnmanaged(i), ref field10.RefSparseSharedUnmanaged(i), ref field11.RefSparseSharedUnmanaged(i), ref field12.RefSparseSharedUnmanaged(i), ref field13.RefSparseSharedUnmanaged(i), ref field14.RefSparseSharedUnmanaged(i), ref field15.RefSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, Ecs.FindIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefManaged(i), ref field1.RefManaged(i), ref field2.RefManaged(i), ref field3.RefManaged(i), ref field4.RefManaged(i), ref field5.RefManaged(i), ref field6.RefManaged(i), ref field7.RefManaged(i), ref field8.RefManaged(i), ref field9.RefManaged(i), ref field10.RefManaged(i), ref field11.RefManaged(i), ref field12.RefManaged(i), ref field13.RefManaged(i), ref field14.RefManaged(i), ref field15.RefManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, Ecs.FindIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSharedManaged(i), ref field1.RefSharedManaged(i), ref field2.RefSharedManaged(i), ref field3.RefSharedManaged(i), ref field4.RefSharedManaged(i), ref field5.RefSharedManaged(i), ref field6.RefSharedManaged(i), ref field7.RefSharedManaged(i), ref field8.RefSharedManaged(i), ref field9.RefSharedManaged(i), ref field10.RefSharedManaged(i), ref field11.RefSharedManaged(i), ref field12.RefSharedManaged(i), ref field13.RefSharedManaged(i), ref field14.RefSharedManaged(i), ref field15.RefSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, Ecs.FindIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSparseManaged(i), ref field1.RefSparseManaged(i), ref field2.RefSparseManaged(i), ref field3.RefSparseManaged(i), ref field4.RefSparseManaged(i), ref field5.RefSparseManaged(i), ref field6.RefSparseManaged(i), ref field7.RefSparseManaged(i), ref field8.RefSparseManaged(i), ref field9.RefSparseManaged(i), ref field10.RefSparseManaged(i), ref field11.RefSparseManaged(i), ref field12.RefSparseManaged(i), ref field13.RefSparseManaged(i), ref field14.RefSparseManaged(i), ref field15.RefSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, Ecs.FindIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSparseSharedManaged(i), ref field1.RefSparseSharedManaged(i), ref field2.RefSparseSharedManaged(i), ref field3.RefSparseSharedManaged(i), ref field4.RefSparseSharedManaged(i), ref field5.RefSparseSharedManaged(i), ref field6.RefSparseSharedManaged(i), ref field7.RefSparseSharedManaged(i), ref field8.RefSparseSharedManaged(i), ref field9.RefSparseSharedManaged(i), ref field10.RefSparseSharedManaged(i), ref field11.RefSparseSharedManaged(i), ref field12.RefSparseSharedManaged(i), ref field13.RefSparseSharedManaged(i), ref field14.RefSparseSharedManaged(i), ref field15.RefSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 
     /// <summary>
@@ -110,25 +442,135 @@ public static Entity Find<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8); byte* pointer9 = (byte*)it.GetPointer<T9>(9); byte* pointer10 = (byte*)it.GetPointer<T10>(10); byte* pointer11 = (byte*)it.GetPointer<T11>(11); byte* pointer12 = (byte*)it.GetPointer<T12>(12); byte* pointer13 = (byte*)it.GetPointer<T13>(13); byte* pointer14 = (byte*)it.GetPointer<T14>(14); byte* pointer15 = (byte*)it.GetPointer<T15>(15);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8); int step9 = it.Step<T9>(9); int step10 = it.Step<T10>(10); int step11 = it.Step<T11>(11); int step12 = it.Step<T12>(12); int step13 = it.Step<T13>(13); int step14 = it.Step<T14>(14); int step15 = it.Step<T15>(15);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8); FieldData<T9> field9 = it.GetFieldData<T9>(9); FieldData<T10> field10 = it.GetFieldData<T10>(10); FieldData<T11> field11 = it.GetFieldData<T11>(11); FieldData<T12> field12 = it.GetFieldData<T12>(12); FieldData<T13> field13 = it.GetFieldData<T13>(13); FieldData<T14> field14 = it.GetFieldData<T14>(14); FieldData<T15> field15 = it.GetFieldData<T15>(15);
+        IterationTechnique flags = it.GetIterationTechnique(16);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8], pointer9 = &pointer9[step9], pointer10 = &pointer10[step10], pointer11 = &pointer11[step11], pointer12 = &pointer12[step12], pointer13 = &pointer13[step13], pointer14 = &pointer14[step14], pointer15 = &pointer15[step15])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>() || RuntimeHelpers.IsReferenceOrContainsReferences<T9>() || RuntimeHelpers.IsReferenceOrContainsReferences<T10>() || RuntimeHelpers.IsReferenceOrContainsReferences<T11>() || RuntimeHelpers.IsReferenceOrContainsReferences<T12>() || RuntimeHelpers.IsReferenceOrContainsReferences<T13>() || RuntimeHelpers.IsReferenceOrContainsReferences<T14>() || RuntimeHelpers.IsReferenceOrContainsReferences<T15>())
         {
-            if (!callback(ref Managed.GetTypeRef<T0>(pointer0), ref Managed.GetTypeRef<T1>(pointer1), ref Managed.GetTypeRef<T2>(pointer2), ref Managed.GetTypeRef<T3>(pointer3), ref Managed.GetTypeRef<T4>(pointer4), ref Managed.GetTypeRef<T5>(pointer5), ref Managed.GetTypeRef<T6>(pointer6), ref Managed.GetTypeRef<T7>(pointer7), ref Managed.GetTypeRef<T8>(pointer8), ref Managed.GetTypeRef<T9>(pointer9), ref Managed.GetTypeRef<T10>(pointer10), ref Managed.GetTypeRef<T11>(pointer11), ref Managed.GetTypeRef<T12>(pointer12), ref Managed.GetTypeRef<T13>(pointer13), ref Managed.GetTypeRef<T14>(pointer14), ref Managed.GetTypeRef<T15>(pointer15)))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, ref T14, ref T15, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefUnmanaged(i), ref field1.RefUnmanaged(i), ref field2.RefUnmanaged(i), ref field3.RefUnmanaged(i), ref field4.RefUnmanaged(i), ref field5.RefUnmanaged(i), ref field6.RefUnmanaged(i), ref field7.RefUnmanaged(i), ref field8.RefUnmanaged(i), ref field9.RefUnmanaged(i), ref field10.RefUnmanaged(i), ref field11.RefUnmanaged(i), ref field12.RefUnmanaged(i), ref field13.RefUnmanaged(i), ref field14.RefUnmanaged(i), ref field15.RefUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, ref T14, ref T15, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSharedUnmanaged(i), ref field1.RefSharedUnmanaged(i), ref field2.RefSharedUnmanaged(i), ref field3.RefSharedUnmanaged(i), ref field4.RefSharedUnmanaged(i), ref field5.RefSharedUnmanaged(i), ref field6.RefSharedUnmanaged(i), ref field7.RefSharedUnmanaged(i), ref field8.RefSharedUnmanaged(i), ref field9.RefSharedUnmanaged(i), ref field10.RefSharedUnmanaged(i), ref field11.RefSharedUnmanaged(i), ref field12.RefSharedUnmanaged(i), ref field13.RefSharedUnmanaged(i), ref field14.RefSharedUnmanaged(i), ref field15.RefSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, ref T14, ref T15, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSparseUnmanaged(i), ref field1.RefSparseUnmanaged(i), ref field2.RefSparseUnmanaged(i), ref field3.RefSparseUnmanaged(i), ref field4.RefSparseUnmanaged(i), ref field5.RefSparseUnmanaged(i), ref field6.RefSparseUnmanaged(i), ref field7.RefSparseUnmanaged(i), ref field8.RefSparseUnmanaged(i), ref field9.RefSparseUnmanaged(i), ref field10.RefSparseUnmanaged(i), ref field11.RefSparseUnmanaged(i), ref field12.RefSparseUnmanaged(i), ref field13.RefSparseUnmanaged(i), ref field14.RefSparseUnmanaged(i), ref field15.RefSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, ref T14, ref T15, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSparseSharedUnmanaged(i), ref field1.RefSparseSharedUnmanaged(i), ref field2.RefSparseSharedUnmanaged(i), ref field3.RefSparseSharedUnmanaged(i), ref field4.RefSparseSharedUnmanaged(i), ref field5.RefSparseSharedUnmanaged(i), ref field6.RefSparseSharedUnmanaged(i), ref field7.RefSparseSharedUnmanaged(i), ref field8.RefSparseSharedUnmanaged(i), ref field9.RefSparseSharedUnmanaged(i), ref field10.RefSparseSharedUnmanaged(i), ref field11.RefSparseSharedUnmanaged(i), ref field12.RefSparseSharedUnmanaged(i), ref field13.RefSparseSharedUnmanaged(i), ref field14.RefSparseSharedUnmanaged(i), ref field15.RefSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, ref T14, ref T15, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefManaged(i), ref field1.RefManaged(i), ref field2.RefManaged(i), ref field3.RefManaged(i), ref field4.RefManaged(i), ref field5.RefManaged(i), ref field6.RefManaged(i), ref field7.RefManaged(i), ref field8.RefManaged(i), ref field9.RefManaged(i), ref field10.RefManaged(i), ref field11.RefManaged(i), ref field12.RefManaged(i), ref field13.RefManaged(i), ref field14.RefManaged(i), ref field15.RefManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, ref T14, ref T15, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSharedManaged(i), ref field1.RefSharedManaged(i), ref field2.RefSharedManaged(i), ref field3.RefSharedManaged(i), ref field4.RefSharedManaged(i), ref field5.RefSharedManaged(i), ref field6.RefSharedManaged(i), ref field7.RefSharedManaged(i), ref field8.RefSharedManaged(i), ref field9.RefSharedManaged(i), ref field10.RefSharedManaged(i), ref field11.RefSharedManaged(i), ref field12.RefSharedManaged(i), ref field13.RefSharedManaged(i), ref field14.RefSharedManaged(i), ref field15.RefSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, ref T14, ref T15, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSparseManaged(i), ref field1.RefSparseManaged(i), ref field2.RefSparseManaged(i), ref field3.RefSparseManaged(i), ref field4.RefSparseManaged(i), ref field5.RefSparseManaged(i), ref field6.RefSparseManaged(i), ref field7.RefSparseManaged(i), ref field8.RefSparseManaged(i), ref field9.RefSparseManaged(i), ref field10.RefSparseManaged(i), ref field11.RefSparseManaged(i), ref field12.RefSparseManaged(i), ref field13.RefSparseManaged(i), ref field14.RefSparseManaged(i), ref field15.RefSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, ref T14, ref T15, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSparseSharedManaged(i), ref field1.RefSparseSharedManaged(i), ref field2.RefSparseSharedManaged(i), ref field3.RefSparseSharedManaged(i), ref field4.RefSparseSharedManaged(i), ref field5.RefSparseSharedManaged(i), ref field6.RefSparseSharedManaged(i), ref field7.RefSparseSharedManaged(i), ref field8.RefSparseSharedManaged(i), ref field9.RefSparseSharedManaged(i), ref field10.RefSparseSharedManaged(i), ref field11.RefSparseSharedManaged(i), ref field12.RefSparseSharedManaged(i), ref field13.RefSparseSharedManaged(i), ref field14.RefSparseSharedManaged(i), ref field15.RefSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 
     /// <summary>
@@ -141,25 +583,135 @@ public static Entity Find<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
     {
         int count = it.Handle->count; Ecs.Assert(it.Handle->count > 0, "No entities returned, use Iter() or Each() without the entity argument instead.");
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8); byte* pointer9 = (byte*)it.GetPointer<T9>(9); byte* pointer10 = (byte*)it.GetPointer<T10>(10); byte* pointer11 = (byte*)it.GetPointer<T11>(11); byte* pointer12 = (byte*)it.GetPointer<T12>(12); byte* pointer13 = (byte*)it.GetPointer<T13>(13); byte* pointer14 = (byte*)it.GetPointer<T14>(14); byte* pointer15 = (byte*)it.GetPointer<T15>(15);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8); int step9 = it.Step<T9>(9); int step10 = it.Step<T10>(10); int step11 = it.Step<T11>(11); int step12 = it.Step<T12>(12); int step13 = it.Step<T13>(13); int step14 = it.Step<T14>(14); int step15 = it.Step<T15>(15);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8); FieldData<T9> field9 = it.GetFieldData<T9>(9); FieldData<T10> field10 = it.GetFieldData<T10>(10); FieldData<T11> field11 = it.GetFieldData<T11>(11); FieldData<T12> field12 = it.GetFieldData<T12>(12); FieldData<T13> field13 = it.GetFieldData<T13>(13); FieldData<T14> field14 = it.GetFieldData<T14>(14); FieldData<T15> field15 = it.GetFieldData<T15>(15);
+        IterationTechnique flags = it.GetIterationTechnique(16);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8], pointer9 = &pointer9[step9], pointer10 = &pointer10[step10], pointer11 = &pointer11[step11], pointer12 = &pointer12[step12], pointer13 = &pointer13[step13], pointer14 = &pointer14[step14], pointer15 = &pointer15[step15])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>() || RuntimeHelpers.IsReferenceOrContainsReferences<T9>() || RuntimeHelpers.IsReferenceOrContainsReferences<T10>() || RuntimeHelpers.IsReferenceOrContainsReferences<T11>() || RuntimeHelpers.IsReferenceOrContainsReferences<T12>() || RuntimeHelpers.IsReferenceOrContainsReferences<T13>() || RuntimeHelpers.IsReferenceOrContainsReferences<T14>() || RuntimeHelpers.IsReferenceOrContainsReferences<T15>())
         {
-            if (!callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref Managed.GetTypeRef<T0>(pointer0), ref Managed.GetTypeRef<T1>(pointer1), ref Managed.GetTypeRef<T2>(pointer2), ref Managed.GetTypeRef<T3>(pointer3), ref Managed.GetTypeRef<T4>(pointer4), ref Managed.GetTypeRef<T5>(pointer5), ref Managed.GetTypeRef<T6>(pointer6), ref Managed.GetTypeRef<T7>(pointer7), ref Managed.GetTypeRef<T8>(pointer8), ref Managed.GetTypeRef<T9>(pointer9), ref Managed.GetTypeRef<T10>(pointer10), ref Managed.GetTypeRef<T11>(pointer11), ref Managed.GetTypeRef<T12>(pointer12), ref Managed.GetTypeRef<T13>(pointer13), ref Managed.GetTypeRef<T14>(pointer14), ref Managed.GetTypeRef<T15>(pointer15)))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, ref T14, ref T15, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefUnmanaged(i), ref field1.RefUnmanaged(i), ref field2.RefUnmanaged(i), ref field3.RefUnmanaged(i), ref field4.RefUnmanaged(i), ref field5.RefUnmanaged(i), ref field6.RefUnmanaged(i), ref field7.RefUnmanaged(i), ref field8.RefUnmanaged(i), ref field9.RefUnmanaged(i), ref field10.RefUnmanaged(i), ref field11.RefUnmanaged(i), ref field12.RefUnmanaged(i), ref field13.RefUnmanaged(i), ref field14.RefUnmanaged(i), ref field15.RefUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, ref T14, ref T15, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSharedUnmanaged(i), ref field1.RefSharedUnmanaged(i), ref field2.RefSharedUnmanaged(i), ref field3.RefSharedUnmanaged(i), ref field4.RefSharedUnmanaged(i), ref field5.RefSharedUnmanaged(i), ref field6.RefSharedUnmanaged(i), ref field7.RefSharedUnmanaged(i), ref field8.RefSharedUnmanaged(i), ref field9.RefSharedUnmanaged(i), ref field10.RefSharedUnmanaged(i), ref field11.RefSharedUnmanaged(i), ref field12.RefSharedUnmanaged(i), ref field13.RefSharedUnmanaged(i), ref field14.RefSharedUnmanaged(i), ref field15.RefSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, ref T14, ref T15, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseUnmanaged(i), ref field1.RefSparseUnmanaged(i), ref field2.RefSparseUnmanaged(i), ref field3.RefSparseUnmanaged(i), ref field4.RefSparseUnmanaged(i), ref field5.RefSparseUnmanaged(i), ref field6.RefSparseUnmanaged(i), ref field7.RefSparseUnmanaged(i), ref field8.RefSparseUnmanaged(i), ref field9.RefSparseUnmanaged(i), ref field10.RefSparseUnmanaged(i), ref field11.RefSparseUnmanaged(i), ref field12.RefSparseUnmanaged(i), ref field13.RefSparseUnmanaged(i), ref field14.RefSparseUnmanaged(i), ref field15.RefSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, ref T14, ref T15, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseSharedUnmanaged(i), ref field1.RefSparseSharedUnmanaged(i), ref field2.RefSparseSharedUnmanaged(i), ref field3.RefSparseSharedUnmanaged(i), ref field4.RefSparseSharedUnmanaged(i), ref field5.RefSparseSharedUnmanaged(i), ref field6.RefSparseSharedUnmanaged(i), ref field7.RefSparseSharedUnmanaged(i), ref field8.RefSparseSharedUnmanaged(i), ref field9.RefSparseSharedUnmanaged(i), ref field10.RefSparseSharedUnmanaged(i), ref field11.RefSparseSharedUnmanaged(i), ref field12.RefSparseSharedUnmanaged(i), ref field13.RefSparseSharedUnmanaged(i), ref field14.RefSparseSharedUnmanaged(i), ref field15.RefSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, ref T14, ref T15, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefManaged(i), ref field1.RefManaged(i), ref field2.RefManaged(i), ref field3.RefManaged(i), ref field4.RefManaged(i), ref field5.RefManaged(i), ref field6.RefManaged(i), ref field7.RefManaged(i), ref field8.RefManaged(i), ref field9.RefManaged(i), ref field10.RefManaged(i), ref field11.RefManaged(i), ref field12.RefManaged(i), ref field13.RefManaged(i), ref field14.RefManaged(i), ref field15.RefManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, ref T14, ref T15, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSharedManaged(i), ref field1.RefSharedManaged(i), ref field2.RefSharedManaged(i), ref field3.RefSharedManaged(i), ref field4.RefSharedManaged(i), ref field5.RefSharedManaged(i), ref field6.RefSharedManaged(i), ref field7.RefSharedManaged(i), ref field8.RefSharedManaged(i), ref field9.RefSharedManaged(i), ref field10.RefSharedManaged(i), ref field11.RefSharedManaged(i), ref field12.RefSharedManaged(i), ref field13.RefSharedManaged(i), ref field14.RefSharedManaged(i), ref field15.RefSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, ref T14, ref T15, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseManaged(i), ref field1.RefSparseManaged(i), ref field2.RefSparseManaged(i), ref field3.RefSparseManaged(i), ref field4.RefSparseManaged(i), ref field5.RefSparseManaged(i), ref field6.RefSparseManaged(i), ref field7.RefSparseManaged(i), ref field8.RefSparseManaged(i), ref field9.RefSparseManaged(i), ref field10.RefSparseManaged(i), ref field11.RefSparseManaged(i), ref field12.RefSparseManaged(i), ref field13.RefSparseManaged(i), ref field14.RefSparseManaged(i), ref field15.RefSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, ref T14, ref T15, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseSharedManaged(i), ref field1.RefSparseSharedManaged(i), ref field2.RefSparseSharedManaged(i), ref field3.RefSparseSharedManaged(i), ref field4.RefSparseSharedManaged(i), ref field5.RefSparseSharedManaged(i), ref field6.RefSparseSharedManaged(i), ref field7.RefSparseSharedManaged(i), ref field8.RefSparseSharedManaged(i), ref field9.RefSparseSharedManaged(i), ref field10.RefSparseSharedManaged(i), ref field11.RefSparseSharedManaged(i), ref field12.RefSparseSharedManaged(i), ref field13.RefSparseSharedManaged(i), ref field14.RefSparseSharedManaged(i), ref field15.RefSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 
     /// <summary>
@@ -172,25 +724,135 @@ public static Entity Find<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8); byte* pointer9 = (byte*)it.GetPointer<T9>(9); byte* pointer10 = (byte*)it.GetPointer<T10>(10); byte* pointer11 = (byte*)it.GetPointer<T11>(11); byte* pointer12 = (byte*)it.GetPointer<T12>(12); byte* pointer13 = (byte*)it.GetPointer<T13>(13); byte* pointer14 = (byte*)it.GetPointer<T14>(14); byte* pointer15 = (byte*)it.GetPointer<T15>(15);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8); int step9 = it.Step<T9>(9); int step10 = it.Step<T10>(10); int step11 = it.Step<T11>(11); int step12 = it.Step<T12>(12); int step13 = it.Step<T13>(13); int step14 = it.Step<T14>(14); int step15 = it.Step<T15>(15);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8); FieldData<T9> field9 = it.GetFieldData<T9>(9); FieldData<T10> field10 = it.GetFieldData<T10>(10); FieldData<T11> field11 = it.GetFieldData<T11>(11); FieldData<T12> field12 = it.GetFieldData<T12>(12); FieldData<T13> field13 = it.GetFieldData<T13>(13); FieldData<T14> field14 = it.GetFieldData<T14>(14); FieldData<T15> field15 = it.GetFieldData<T15>(15);
+        IterationTechnique flags = it.GetIterationTechnique(16);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8], pointer9 = &pointer9[step9], pointer10 = &pointer10[step10], pointer11 = &pointer11[step11], pointer12 = &pointer12[step12], pointer13 = &pointer13[step13], pointer14 = &pointer14[step14], pointer15 = &pointer15[step15])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>() || RuntimeHelpers.IsReferenceOrContainsReferences<T9>() || RuntimeHelpers.IsReferenceOrContainsReferences<T10>() || RuntimeHelpers.IsReferenceOrContainsReferences<T11>() || RuntimeHelpers.IsReferenceOrContainsReferences<T12>() || RuntimeHelpers.IsReferenceOrContainsReferences<T13>() || RuntimeHelpers.IsReferenceOrContainsReferences<T14>() || RuntimeHelpers.IsReferenceOrContainsReferences<T15>())
         {
-            if (!callback(it, i, ref Managed.GetTypeRef<T0>(pointer0), ref Managed.GetTypeRef<T1>(pointer1), ref Managed.GetTypeRef<T2>(pointer2), ref Managed.GetTypeRef<T3>(pointer3), ref Managed.GetTypeRef<T4>(pointer4), ref Managed.GetTypeRef<T5>(pointer5), ref Managed.GetTypeRef<T6>(pointer6), ref Managed.GetTypeRef<T7>(pointer7), ref Managed.GetTypeRef<T8>(pointer8), ref Managed.GetTypeRef<T9>(pointer9), ref Managed.GetTypeRef<T10>(pointer10), ref Managed.GetTypeRef<T11>(pointer11), ref Managed.GetTypeRef<T12>(pointer12), ref Managed.GetTypeRef<T13>(pointer13), ref Managed.GetTypeRef<T14>(pointer14), ref Managed.GetTypeRef<T15>(pointer15)))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, ref T14, ref T15, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefUnmanaged(i), ref field1.RefUnmanaged(i), ref field2.RefUnmanaged(i), ref field3.RefUnmanaged(i), ref field4.RefUnmanaged(i), ref field5.RefUnmanaged(i), ref field6.RefUnmanaged(i), ref field7.RefUnmanaged(i), ref field8.RefUnmanaged(i), ref field9.RefUnmanaged(i), ref field10.RefUnmanaged(i), ref field11.RefUnmanaged(i), ref field12.RefUnmanaged(i), ref field13.RefUnmanaged(i), ref field14.RefUnmanaged(i), ref field15.RefUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, ref T14, ref T15, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSharedUnmanaged(i), ref field1.RefSharedUnmanaged(i), ref field2.RefSharedUnmanaged(i), ref field3.RefSharedUnmanaged(i), ref field4.RefSharedUnmanaged(i), ref field5.RefSharedUnmanaged(i), ref field6.RefSharedUnmanaged(i), ref field7.RefSharedUnmanaged(i), ref field8.RefSharedUnmanaged(i), ref field9.RefSharedUnmanaged(i), ref field10.RefSharedUnmanaged(i), ref field11.RefSharedUnmanaged(i), ref field12.RefSharedUnmanaged(i), ref field13.RefSharedUnmanaged(i), ref field14.RefSharedUnmanaged(i), ref field15.RefSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, ref T14, ref T15, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSparseUnmanaged(i), ref field1.RefSparseUnmanaged(i), ref field2.RefSparseUnmanaged(i), ref field3.RefSparseUnmanaged(i), ref field4.RefSparseUnmanaged(i), ref field5.RefSparseUnmanaged(i), ref field6.RefSparseUnmanaged(i), ref field7.RefSparseUnmanaged(i), ref field8.RefSparseUnmanaged(i), ref field9.RefSparseUnmanaged(i), ref field10.RefSparseUnmanaged(i), ref field11.RefSparseUnmanaged(i), ref field12.RefSparseUnmanaged(i), ref field13.RefSparseUnmanaged(i), ref field14.RefSparseUnmanaged(i), ref field15.RefSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, ref T14, ref T15, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSparseSharedUnmanaged(i), ref field1.RefSparseSharedUnmanaged(i), ref field2.RefSparseSharedUnmanaged(i), ref field3.RefSparseSharedUnmanaged(i), ref field4.RefSparseSharedUnmanaged(i), ref field5.RefSparseSharedUnmanaged(i), ref field6.RefSparseSharedUnmanaged(i), ref field7.RefSparseSharedUnmanaged(i), ref field8.RefSparseSharedUnmanaged(i), ref field9.RefSparseSharedUnmanaged(i), ref field10.RefSparseSharedUnmanaged(i), ref field11.RefSparseSharedUnmanaged(i), ref field12.RefSparseSharedUnmanaged(i), ref field13.RefSparseSharedUnmanaged(i), ref field14.RefSparseSharedUnmanaged(i), ref field15.RefSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, ref T14, ref T15, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefManaged(i), ref field1.RefManaged(i), ref field2.RefManaged(i), ref field3.RefManaged(i), ref field4.RefManaged(i), ref field5.RefManaged(i), ref field6.RefManaged(i), ref field7.RefManaged(i), ref field8.RefManaged(i), ref field9.RefManaged(i), ref field10.RefManaged(i), ref field11.RefManaged(i), ref field12.RefManaged(i), ref field13.RefManaged(i), ref field14.RefManaged(i), ref field15.RefManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, ref T14, ref T15, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSharedManaged(i), ref field1.RefSharedManaged(i), ref field2.RefSharedManaged(i), ref field3.RefSharedManaged(i), ref field4.RefSharedManaged(i), ref field5.RefSharedManaged(i), ref field6.RefSharedManaged(i), ref field7.RefSharedManaged(i), ref field8.RefSharedManaged(i), ref field9.RefSharedManaged(i), ref field10.RefSharedManaged(i), ref field11.RefSharedManaged(i), ref field12.RefSharedManaged(i), ref field13.RefSharedManaged(i), ref field14.RefSharedManaged(i), ref field15.RefSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, ref T14, ref T15, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSparseManaged(i), ref field1.RefSparseManaged(i), ref field2.RefSparseManaged(i), ref field3.RefSparseManaged(i), ref field4.RefSparseManaged(i), ref field5.RefSparseManaged(i), ref field6.RefSparseManaged(i), ref field7.RefSparseManaged(i), ref field8.RefSparseManaged(i), ref field9.RefSparseManaged(i), ref field10.RefSparseManaged(i), ref field11.RefSparseManaged(i), ref field12.RefSparseManaged(i), ref field13.RefSparseManaged(i), ref field14.RefSparseManaged(i), ref field15.RefSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, ref T14, ref T15, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSparseSharedManaged(i), ref field1.RefSparseSharedManaged(i), ref field2.RefSparseSharedManaged(i), ref field3.RefSparseSharedManaged(i), ref field4.RefSparseSharedManaged(i), ref field5.RefSparseSharedManaged(i), ref field6.RefSparseSharedManaged(i), ref field7.RefSparseSharedManaged(i), ref field8.RefSparseSharedManaged(i), ref field9.RefSparseSharedManaged(i), ref field10.RefSparseSharedManaged(i), ref field11.RefSparseSharedManaged(i), ref field12.RefSparseSharedManaged(i), ref field13.RefSparseSharedManaged(i), ref field14.RefSparseSharedManaged(i), ref field15.RefSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 
     /// <summary>
@@ -203,25 +865,135 @@ public static Entity Find<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8); byte* pointer9 = (byte*)it.GetPointer<T9>(9); byte* pointer10 = (byte*)it.GetPointer<T10>(10); byte* pointer11 = (byte*)it.GetPointer<T11>(11); byte* pointer12 = (byte*)it.GetPointer<T12>(12); byte* pointer13 = (byte*)it.GetPointer<T13>(13); byte* pointer14 = (byte*)it.GetPointer<T14>(14); byte* pointer15 = (byte*)it.GetPointer<T15>(15);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8); int step9 = it.Step<T9>(9); int step10 = it.Step<T10>(10); int step11 = it.Step<T11>(11); int step12 = it.Step<T12>(12); int step13 = it.Step<T13>(13); int step14 = it.Step<T14>(14); int step15 = it.Step<T15>(15);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8); FieldData<T9> field9 = it.GetFieldData<T9>(9); FieldData<T10> field10 = it.GetFieldData<T10>(10); FieldData<T11> field11 = it.GetFieldData<T11>(11); FieldData<T12> field12 = it.GetFieldData<T12>(12); FieldData<T13> field13 = it.GetFieldData<T13>(13); FieldData<T14> field14 = it.GetFieldData<T14>(14); FieldData<T15> field15 = it.GetFieldData<T15>(15);
+        IterationTechnique flags = it.GetIterationTechnique(16);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8], pointer9 = &pointer9[step9], pointer10 = &pointer10[step10], pointer11 = &pointer11[step11], pointer12 = &pointer12[step12], pointer13 = &pointer13[step13], pointer14 = &pointer14[step14], pointer15 = &pointer15[step15])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>() || RuntimeHelpers.IsReferenceOrContainsReferences<T9>() || RuntimeHelpers.IsReferenceOrContainsReferences<T10>() || RuntimeHelpers.IsReferenceOrContainsReferences<T11>() || RuntimeHelpers.IsReferenceOrContainsReferences<T12>() || RuntimeHelpers.IsReferenceOrContainsReferences<T13>() || RuntimeHelpers.IsReferenceOrContainsReferences<T14>() || RuntimeHelpers.IsReferenceOrContainsReferences<T15>())
         {
-            if (!callback((T0*)pointer0, (T1*)pointer1, (T2*)pointer2, (T3*)pointer3, (T4*)pointer4, (T5*)pointer5, (T6*)pointer6, (T7*)pointer7, (T8*)pointer8, (T9*)pointer9, (T10*)pointer10, (T11*)pointer11, (T12*)pointer12, (T13*)pointer13, (T14*)pointer14, (T15*)pointer15))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, Ecs.FindPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerUnmanaged(i), field1.PointerUnmanaged(i), field2.PointerUnmanaged(i), field3.PointerUnmanaged(i), field4.PointerUnmanaged(i), field5.PointerUnmanaged(i), field6.PointerUnmanaged(i), field7.PointerUnmanaged(i), field8.PointerUnmanaged(i), field9.PointerUnmanaged(i), field10.PointerUnmanaged(i), field11.PointerUnmanaged(i), field12.PointerUnmanaged(i), field13.PointerUnmanaged(i), field14.PointerUnmanaged(i), field15.PointerUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, Ecs.FindPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSharedUnmanaged(i), field1.PointerSharedUnmanaged(i), field2.PointerSharedUnmanaged(i), field3.PointerSharedUnmanaged(i), field4.PointerSharedUnmanaged(i), field5.PointerSharedUnmanaged(i), field6.PointerSharedUnmanaged(i), field7.PointerSharedUnmanaged(i), field8.PointerSharedUnmanaged(i), field9.PointerSharedUnmanaged(i), field10.PointerSharedUnmanaged(i), field11.PointerSharedUnmanaged(i), field12.PointerSharedUnmanaged(i), field13.PointerSharedUnmanaged(i), field14.PointerSharedUnmanaged(i), field15.PointerSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, Ecs.FindPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSparseUnmanaged(i), field1.PointerSparseUnmanaged(i), field2.PointerSparseUnmanaged(i), field3.PointerSparseUnmanaged(i), field4.PointerSparseUnmanaged(i), field5.PointerSparseUnmanaged(i), field6.PointerSparseUnmanaged(i), field7.PointerSparseUnmanaged(i), field8.PointerSparseUnmanaged(i), field9.PointerSparseUnmanaged(i), field10.PointerSparseUnmanaged(i), field11.PointerSparseUnmanaged(i), field12.PointerSparseUnmanaged(i), field13.PointerSparseUnmanaged(i), field14.PointerSparseUnmanaged(i), field15.PointerSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, Ecs.FindPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSparseSharedUnmanaged(i), field1.PointerSparseSharedUnmanaged(i), field2.PointerSparseSharedUnmanaged(i), field3.PointerSparseSharedUnmanaged(i), field4.PointerSparseSharedUnmanaged(i), field5.PointerSparseSharedUnmanaged(i), field6.PointerSparseSharedUnmanaged(i), field7.PointerSparseSharedUnmanaged(i), field8.PointerSparseSharedUnmanaged(i), field9.PointerSparseSharedUnmanaged(i), field10.PointerSparseSharedUnmanaged(i), field11.PointerSparseSharedUnmanaged(i), field12.PointerSparseSharedUnmanaged(i), field13.PointerSparseSharedUnmanaged(i), field14.PointerSparseSharedUnmanaged(i), field15.PointerSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, Ecs.FindPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerManaged(i), field1.PointerManaged(i), field2.PointerManaged(i), field3.PointerManaged(i), field4.PointerManaged(i), field5.PointerManaged(i), field6.PointerManaged(i), field7.PointerManaged(i), field8.PointerManaged(i), field9.PointerManaged(i), field10.PointerManaged(i), field11.PointerManaged(i), field12.PointerManaged(i), field13.PointerManaged(i), field14.PointerManaged(i), field15.PointerManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, Ecs.FindPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSharedManaged(i), field1.PointerSharedManaged(i), field2.PointerSharedManaged(i), field3.PointerSharedManaged(i), field4.PointerSharedManaged(i), field5.PointerSharedManaged(i), field6.PointerSharedManaged(i), field7.PointerSharedManaged(i), field8.PointerSharedManaged(i), field9.PointerSharedManaged(i), field10.PointerSharedManaged(i), field11.PointerSharedManaged(i), field12.PointerSharedManaged(i), field13.PointerSharedManaged(i), field14.PointerSharedManaged(i), field15.PointerSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, Ecs.FindPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSparseManaged(i), field1.PointerSparseManaged(i), field2.PointerSparseManaged(i), field3.PointerSparseManaged(i), field4.PointerSparseManaged(i), field5.PointerSparseManaged(i), field6.PointerSparseManaged(i), field7.PointerSparseManaged(i), field8.PointerSparseManaged(i), field9.PointerSparseManaged(i), field10.PointerSparseManaged(i), field11.PointerSparseManaged(i), field12.PointerSparseManaged(i), field13.PointerSparseManaged(i), field14.PointerSparseManaged(i), field15.PointerSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, Ecs.FindPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSparseSharedManaged(i), field1.PointerSparseSharedManaged(i), field2.PointerSparseSharedManaged(i), field3.PointerSparseSharedManaged(i), field4.PointerSparseSharedManaged(i), field5.PointerSparseSharedManaged(i), field6.PointerSparseSharedManaged(i), field7.PointerSparseSharedManaged(i), field8.PointerSparseSharedManaged(i), field9.PointerSparseSharedManaged(i), field10.PointerSparseSharedManaged(i), field11.PointerSparseSharedManaged(i), field12.PointerSparseSharedManaged(i), field13.PointerSparseSharedManaged(i), field14.PointerSparseSharedManaged(i), field15.PointerSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 
     /// <summary>
@@ -234,25 +1006,135 @@ public static Entity Find<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
     {
         int count = it.Handle->count; Ecs.Assert(it.Handle->count > 0, "No entities returned, use Iter() or Each() without the entity argument instead.");
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8); byte* pointer9 = (byte*)it.GetPointer<T9>(9); byte* pointer10 = (byte*)it.GetPointer<T10>(10); byte* pointer11 = (byte*)it.GetPointer<T11>(11); byte* pointer12 = (byte*)it.GetPointer<T12>(12); byte* pointer13 = (byte*)it.GetPointer<T13>(13); byte* pointer14 = (byte*)it.GetPointer<T14>(14); byte* pointer15 = (byte*)it.GetPointer<T15>(15);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8); int step9 = it.Step<T9>(9); int step10 = it.Step<T10>(10); int step11 = it.Step<T11>(11); int step12 = it.Step<T12>(12); int step13 = it.Step<T13>(13); int step14 = it.Step<T14>(14); int step15 = it.Step<T15>(15);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8); FieldData<T9> field9 = it.GetFieldData<T9>(9); FieldData<T10> field10 = it.GetFieldData<T10>(10); FieldData<T11> field11 = it.GetFieldData<T11>(11); FieldData<T12> field12 = it.GetFieldData<T12>(12); FieldData<T13> field13 = it.GetFieldData<T13>(13); FieldData<T14> field14 = it.GetFieldData<T14>(14); FieldData<T15> field15 = it.GetFieldData<T15>(15);
+        IterationTechnique flags = it.GetIterationTechnique(16);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8], pointer9 = &pointer9[step9], pointer10 = &pointer10[step10], pointer11 = &pointer11[step11], pointer12 = &pointer12[step12], pointer13 = &pointer13[step13], pointer14 = &pointer14[step14], pointer15 = &pointer15[step15])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>() || RuntimeHelpers.IsReferenceOrContainsReferences<T9>() || RuntimeHelpers.IsReferenceOrContainsReferences<T10>() || RuntimeHelpers.IsReferenceOrContainsReferences<T11>() || RuntimeHelpers.IsReferenceOrContainsReferences<T12>() || RuntimeHelpers.IsReferenceOrContainsReferences<T13>() || RuntimeHelpers.IsReferenceOrContainsReferences<T14>() || RuntimeHelpers.IsReferenceOrContainsReferences<T15>())
         {
-            if (!callback(new Entity(it.Handle->world, it.Handle->entities[i]), (T0*)pointer0, (T1*)pointer1, (T2*)pointer2, (T3*)pointer3, (T4*)pointer4, (T5*)pointer5, (T6*)pointer6, (T7*)pointer7, (T8*)pointer8, (T9*)pointer9, (T10*)pointer10, (T11*)pointer11, (T12*)pointer12, (T13*)pointer13, (T14*)pointer14, (T15*)pointer15))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerUnmanaged(i), field1.PointerUnmanaged(i), field2.PointerUnmanaged(i), field3.PointerUnmanaged(i), field4.PointerUnmanaged(i), field5.PointerUnmanaged(i), field6.PointerUnmanaged(i), field7.PointerUnmanaged(i), field8.PointerUnmanaged(i), field9.PointerUnmanaged(i), field10.PointerUnmanaged(i), field11.PointerUnmanaged(i), field12.PointerUnmanaged(i), field13.PointerUnmanaged(i), field14.PointerUnmanaged(i), field15.PointerUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSharedUnmanaged(i), field1.PointerSharedUnmanaged(i), field2.PointerSharedUnmanaged(i), field3.PointerSharedUnmanaged(i), field4.PointerSharedUnmanaged(i), field5.PointerSharedUnmanaged(i), field6.PointerSharedUnmanaged(i), field7.PointerSharedUnmanaged(i), field8.PointerSharedUnmanaged(i), field9.PointerSharedUnmanaged(i), field10.PointerSharedUnmanaged(i), field11.PointerSharedUnmanaged(i), field12.PointerSharedUnmanaged(i), field13.PointerSharedUnmanaged(i), field14.PointerSharedUnmanaged(i), field15.PointerSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseUnmanaged(i), field1.PointerSparseUnmanaged(i), field2.PointerSparseUnmanaged(i), field3.PointerSparseUnmanaged(i), field4.PointerSparseUnmanaged(i), field5.PointerSparseUnmanaged(i), field6.PointerSparseUnmanaged(i), field7.PointerSparseUnmanaged(i), field8.PointerSparseUnmanaged(i), field9.PointerSparseUnmanaged(i), field10.PointerSparseUnmanaged(i), field11.PointerSparseUnmanaged(i), field12.PointerSparseUnmanaged(i), field13.PointerSparseUnmanaged(i), field14.PointerSparseUnmanaged(i), field15.PointerSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseSharedUnmanaged(i), field1.PointerSparseSharedUnmanaged(i), field2.PointerSparseSharedUnmanaged(i), field3.PointerSparseSharedUnmanaged(i), field4.PointerSparseSharedUnmanaged(i), field5.PointerSparseSharedUnmanaged(i), field6.PointerSparseSharedUnmanaged(i), field7.PointerSparseSharedUnmanaged(i), field8.PointerSparseSharedUnmanaged(i), field9.PointerSparseSharedUnmanaged(i), field10.PointerSparseSharedUnmanaged(i), field11.PointerSparseSharedUnmanaged(i), field12.PointerSparseSharedUnmanaged(i), field13.PointerSparseSharedUnmanaged(i), field14.PointerSparseSharedUnmanaged(i), field15.PointerSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerManaged(i), field1.PointerManaged(i), field2.PointerManaged(i), field3.PointerManaged(i), field4.PointerManaged(i), field5.PointerManaged(i), field6.PointerManaged(i), field7.PointerManaged(i), field8.PointerManaged(i), field9.PointerManaged(i), field10.PointerManaged(i), field11.PointerManaged(i), field12.PointerManaged(i), field13.PointerManaged(i), field14.PointerManaged(i), field15.PointerManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSharedManaged(i), field1.PointerSharedManaged(i), field2.PointerSharedManaged(i), field3.PointerSharedManaged(i), field4.PointerSharedManaged(i), field5.PointerSharedManaged(i), field6.PointerSharedManaged(i), field7.PointerSharedManaged(i), field8.PointerSharedManaged(i), field9.PointerSharedManaged(i), field10.PointerSharedManaged(i), field11.PointerSharedManaged(i), field12.PointerSharedManaged(i), field13.PointerSharedManaged(i), field14.PointerSharedManaged(i), field15.PointerSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseManaged(i), field1.PointerSparseManaged(i), field2.PointerSparseManaged(i), field3.PointerSparseManaged(i), field4.PointerSparseManaged(i), field5.PointerSparseManaged(i), field6.PointerSparseManaged(i), field7.PointerSparseManaged(i), field8.PointerSparseManaged(i), field9.PointerSparseManaged(i), field10.PointerSparseManaged(i), field11.PointerSparseManaged(i), field12.PointerSparseManaged(i), field13.PointerSparseManaged(i), field14.PointerSparseManaged(i), field15.PointerSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseSharedManaged(i), field1.PointerSparseSharedManaged(i), field2.PointerSparseSharedManaged(i), field3.PointerSparseSharedManaged(i), field4.PointerSparseSharedManaged(i), field5.PointerSparseSharedManaged(i), field6.PointerSparseSharedManaged(i), field7.PointerSparseSharedManaged(i), field8.PointerSparseSharedManaged(i), field9.PointerSparseSharedManaged(i), field10.PointerSparseSharedManaged(i), field11.PointerSparseSharedManaged(i), field12.PointerSparseSharedManaged(i), field13.PointerSparseSharedManaged(i), field14.PointerSparseSharedManaged(i), field15.PointerSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 
     /// <summary>
@@ -265,25 +1147,135 @@ public static Entity Find<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8); byte* pointer9 = (byte*)it.GetPointer<T9>(9); byte* pointer10 = (byte*)it.GetPointer<T10>(10); byte* pointer11 = (byte*)it.GetPointer<T11>(11); byte* pointer12 = (byte*)it.GetPointer<T12>(12); byte* pointer13 = (byte*)it.GetPointer<T13>(13); byte* pointer14 = (byte*)it.GetPointer<T14>(14); byte* pointer15 = (byte*)it.GetPointer<T15>(15);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8); int step9 = it.Step<T9>(9); int step10 = it.Step<T10>(10); int step11 = it.Step<T11>(11); int step12 = it.Step<T12>(12); int step13 = it.Step<T13>(13); int step14 = it.Step<T14>(14); int step15 = it.Step<T15>(15);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8); FieldData<T9> field9 = it.GetFieldData<T9>(9); FieldData<T10> field10 = it.GetFieldData<T10>(10); FieldData<T11> field11 = it.GetFieldData<T11>(11); FieldData<T12> field12 = it.GetFieldData<T12>(12); FieldData<T13> field13 = it.GetFieldData<T13>(13); FieldData<T14> field14 = it.GetFieldData<T14>(14); FieldData<T15> field15 = it.GetFieldData<T15>(15);
+        IterationTechnique flags = it.GetIterationTechnique(16);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8], pointer9 = &pointer9[step9], pointer10 = &pointer10[step10], pointer11 = &pointer11[step11], pointer12 = &pointer12[step12], pointer13 = &pointer13[step13], pointer14 = &pointer14[step14], pointer15 = &pointer15[step15])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>() || RuntimeHelpers.IsReferenceOrContainsReferences<T9>() || RuntimeHelpers.IsReferenceOrContainsReferences<T10>() || RuntimeHelpers.IsReferenceOrContainsReferences<T11>() || RuntimeHelpers.IsReferenceOrContainsReferences<T12>() || RuntimeHelpers.IsReferenceOrContainsReferences<T13>() || RuntimeHelpers.IsReferenceOrContainsReferences<T14>() || RuntimeHelpers.IsReferenceOrContainsReferences<T15>())
         {
-            if (!callback(it, i, (T0*)pointer0, (T1*)pointer1, (T2*)pointer2, (T3*)pointer3, (T4*)pointer4, (T5*)pointer5, (T6*)pointer6, (T7*)pointer7, (T8*)pointer8, (T9*)pointer9, (T10*)pointer10, (T11*)pointer11, (T12*)pointer12, (T13*)pointer13, (T14*)pointer14, (T15*)pointer15))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerUnmanaged(i), field1.PointerUnmanaged(i), field2.PointerUnmanaged(i), field3.PointerUnmanaged(i), field4.PointerUnmanaged(i), field5.PointerUnmanaged(i), field6.PointerUnmanaged(i), field7.PointerUnmanaged(i), field8.PointerUnmanaged(i), field9.PointerUnmanaged(i), field10.PointerUnmanaged(i), field11.PointerUnmanaged(i), field12.PointerUnmanaged(i), field13.PointerUnmanaged(i), field14.PointerUnmanaged(i), field15.PointerUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSharedUnmanaged(i), field1.PointerSharedUnmanaged(i), field2.PointerSharedUnmanaged(i), field3.PointerSharedUnmanaged(i), field4.PointerSharedUnmanaged(i), field5.PointerSharedUnmanaged(i), field6.PointerSharedUnmanaged(i), field7.PointerSharedUnmanaged(i), field8.PointerSharedUnmanaged(i), field9.PointerSharedUnmanaged(i), field10.PointerSharedUnmanaged(i), field11.PointerSharedUnmanaged(i), field12.PointerSharedUnmanaged(i), field13.PointerSharedUnmanaged(i), field14.PointerSharedUnmanaged(i), field15.PointerSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSparseUnmanaged(i), field1.PointerSparseUnmanaged(i), field2.PointerSparseUnmanaged(i), field3.PointerSparseUnmanaged(i), field4.PointerSparseUnmanaged(i), field5.PointerSparseUnmanaged(i), field6.PointerSparseUnmanaged(i), field7.PointerSparseUnmanaged(i), field8.PointerSparseUnmanaged(i), field9.PointerSparseUnmanaged(i), field10.PointerSparseUnmanaged(i), field11.PointerSparseUnmanaged(i), field12.PointerSparseUnmanaged(i), field13.PointerSparseUnmanaged(i), field14.PointerSparseUnmanaged(i), field15.PointerSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSparseSharedUnmanaged(i), field1.PointerSparseSharedUnmanaged(i), field2.PointerSparseSharedUnmanaged(i), field3.PointerSparseSharedUnmanaged(i), field4.PointerSparseSharedUnmanaged(i), field5.PointerSparseSharedUnmanaged(i), field6.PointerSparseSharedUnmanaged(i), field7.PointerSparseSharedUnmanaged(i), field8.PointerSparseSharedUnmanaged(i), field9.PointerSparseSharedUnmanaged(i), field10.PointerSparseSharedUnmanaged(i), field11.PointerSparseSharedUnmanaged(i), field12.PointerSparseSharedUnmanaged(i), field13.PointerSparseSharedUnmanaged(i), field14.PointerSparseSharedUnmanaged(i), field15.PointerSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerManaged(i), field1.PointerManaged(i), field2.PointerManaged(i), field3.PointerManaged(i), field4.PointerManaged(i), field5.PointerManaged(i), field6.PointerManaged(i), field7.PointerManaged(i), field8.PointerManaged(i), field9.PointerManaged(i), field10.PointerManaged(i), field11.PointerManaged(i), field12.PointerManaged(i), field13.PointerManaged(i), field14.PointerManaged(i), field15.PointerManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSharedManaged(i), field1.PointerSharedManaged(i), field2.PointerSharedManaged(i), field3.PointerSharedManaged(i), field4.PointerSharedManaged(i), field5.PointerSharedManaged(i), field6.PointerSharedManaged(i), field7.PointerSharedManaged(i), field8.PointerSharedManaged(i), field9.PointerSharedManaged(i), field10.PointerSharedManaged(i), field11.PointerSharedManaged(i), field12.PointerSharedManaged(i), field13.PointerSharedManaged(i), field14.PointerSharedManaged(i), field15.PointerSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSparseManaged(i), field1.PointerSparseManaged(i), field2.PointerSparseManaged(i), field3.PointerSparseManaged(i), field4.PointerSparseManaged(i), field5.PointerSparseManaged(i), field6.PointerSparseManaged(i), field7.PointerSparseManaged(i), field8.PointerSparseManaged(i), field9.PointerSparseManaged(i), field10.PointerSparseManaged(i), field11.PointerSparseManaged(i), field12.PointerSparseManaged(i), field13.PointerSparseManaged(i), field14.PointerSparseManaged(i), field15.PointerSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSparseSharedManaged(i), field1.PointerSparseSharedManaged(i), field2.PointerSparseSharedManaged(i), field3.PointerSparseSharedManaged(i), field4.PointerSparseSharedManaged(i), field5.PointerSparseSharedManaged(i), field6.PointerSparseSharedManaged(i), field7.PointerSparseSharedManaged(i), field8.PointerSparseSharedManaged(i), field9.PointerSparseSharedManaged(i), field10.PointerSparseSharedManaged(i), field11.PointerSparseSharedManaged(i), field12.PointerSparseSharedManaged(i), field13.PointerSparseSharedManaged(i), field14.PointerSparseSharedManaged(i), field15.PointerSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 
     /// <summary>
@@ -296,25 +1288,135 @@ public static Entity Find<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8); byte* pointer9 = (byte*)it.GetPointer<T9>(9); byte* pointer10 = (byte*)it.GetPointer<T10>(10); byte* pointer11 = (byte*)it.GetPointer<T11>(11); byte* pointer12 = (byte*)it.GetPointer<T12>(12); byte* pointer13 = (byte*)it.GetPointer<T13>(13); byte* pointer14 = (byte*)it.GetPointer<T14>(14); byte* pointer15 = (byte*)it.GetPointer<T15>(15);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8); int step9 = it.Step<T9>(9); int step10 = it.Step<T10>(10); int step11 = it.Step<T11>(11); int step12 = it.Step<T12>(12); int step13 = it.Step<T13>(13); int step14 = it.Step<T14>(14); int step15 = it.Step<T15>(15);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8); FieldData<T9> field9 = it.GetFieldData<T9>(9); FieldData<T10> field10 = it.GetFieldData<T10>(10); FieldData<T11> field11 = it.GetFieldData<T11>(11); FieldData<T12> field12 = it.GetFieldData<T12>(12); FieldData<T13> field13 = it.GetFieldData<T13>(13); FieldData<T14> field14 = it.GetFieldData<T14>(14); FieldData<T15> field15 = it.GetFieldData<T15>(15);
+        IterationTechnique flags = it.GetIterationTechnique(16);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8], pointer9 = &pointer9[step9], pointer10 = &pointer10[step10], pointer11 = &pointer11[step11], pointer12 = &pointer12[step12], pointer13 = &pointer13[step13], pointer14 = &pointer14[step14], pointer15 = &pointer15[step15])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>() || RuntimeHelpers.IsReferenceOrContainsReferences<T9>() || RuntimeHelpers.IsReferenceOrContainsReferences<T10>() || RuntimeHelpers.IsReferenceOrContainsReferences<T11>() || RuntimeHelpers.IsReferenceOrContainsReferences<T12>() || RuntimeHelpers.IsReferenceOrContainsReferences<T13>() || RuntimeHelpers.IsReferenceOrContainsReferences<T14>() || RuntimeHelpers.IsReferenceOrContainsReferences<T15>())
         {
-            if (!callback((T0*)pointer0, (T1*)pointer1, (T2*)pointer2, (T3*)pointer3, (T4*)pointer4, (T5*)pointer5, (T6*)pointer6, (T7*)pointer7, (T8*)pointer8, (T9*)pointer9, (T10*)pointer10, (T11*)pointer11, (T12*)pointer12, (T13*)pointer13, (T14*)pointer14, (T15*)pointer15))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, T14*, T15*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerUnmanaged(i), field1.PointerUnmanaged(i), field2.PointerUnmanaged(i), field3.PointerUnmanaged(i), field4.PointerUnmanaged(i), field5.PointerUnmanaged(i), field6.PointerUnmanaged(i), field7.PointerUnmanaged(i), field8.PointerUnmanaged(i), field9.PointerUnmanaged(i), field10.PointerUnmanaged(i), field11.PointerUnmanaged(i), field12.PointerUnmanaged(i), field13.PointerUnmanaged(i), field14.PointerUnmanaged(i), field15.PointerUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, T14*, T15*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSharedUnmanaged(i), field1.PointerSharedUnmanaged(i), field2.PointerSharedUnmanaged(i), field3.PointerSharedUnmanaged(i), field4.PointerSharedUnmanaged(i), field5.PointerSharedUnmanaged(i), field6.PointerSharedUnmanaged(i), field7.PointerSharedUnmanaged(i), field8.PointerSharedUnmanaged(i), field9.PointerSharedUnmanaged(i), field10.PointerSharedUnmanaged(i), field11.PointerSharedUnmanaged(i), field12.PointerSharedUnmanaged(i), field13.PointerSharedUnmanaged(i), field14.PointerSharedUnmanaged(i), field15.PointerSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, T14*, T15*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSparseUnmanaged(i), field1.PointerSparseUnmanaged(i), field2.PointerSparseUnmanaged(i), field3.PointerSparseUnmanaged(i), field4.PointerSparseUnmanaged(i), field5.PointerSparseUnmanaged(i), field6.PointerSparseUnmanaged(i), field7.PointerSparseUnmanaged(i), field8.PointerSparseUnmanaged(i), field9.PointerSparseUnmanaged(i), field10.PointerSparseUnmanaged(i), field11.PointerSparseUnmanaged(i), field12.PointerSparseUnmanaged(i), field13.PointerSparseUnmanaged(i), field14.PointerSparseUnmanaged(i), field15.PointerSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, T14*, T15*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSparseSharedUnmanaged(i), field1.PointerSparseSharedUnmanaged(i), field2.PointerSparseSharedUnmanaged(i), field3.PointerSparseSharedUnmanaged(i), field4.PointerSparseSharedUnmanaged(i), field5.PointerSparseSharedUnmanaged(i), field6.PointerSparseSharedUnmanaged(i), field7.PointerSparseSharedUnmanaged(i), field8.PointerSparseSharedUnmanaged(i), field9.PointerSparseSharedUnmanaged(i), field10.PointerSparseSharedUnmanaged(i), field11.PointerSparseSharedUnmanaged(i), field12.PointerSparseSharedUnmanaged(i), field13.PointerSparseSharedUnmanaged(i), field14.PointerSparseSharedUnmanaged(i), field15.PointerSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, T14*, T15*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerManaged(i), field1.PointerManaged(i), field2.PointerManaged(i), field3.PointerManaged(i), field4.PointerManaged(i), field5.PointerManaged(i), field6.PointerManaged(i), field7.PointerManaged(i), field8.PointerManaged(i), field9.PointerManaged(i), field10.PointerManaged(i), field11.PointerManaged(i), field12.PointerManaged(i), field13.PointerManaged(i), field14.PointerManaged(i), field15.PointerManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, T14*, T15*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSharedManaged(i), field1.PointerSharedManaged(i), field2.PointerSharedManaged(i), field3.PointerSharedManaged(i), field4.PointerSharedManaged(i), field5.PointerSharedManaged(i), field6.PointerSharedManaged(i), field7.PointerSharedManaged(i), field8.PointerSharedManaged(i), field9.PointerSharedManaged(i), field10.PointerSharedManaged(i), field11.PointerSharedManaged(i), field12.PointerSharedManaged(i), field13.PointerSharedManaged(i), field14.PointerSharedManaged(i), field15.PointerSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, T14*, T15*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSparseManaged(i), field1.PointerSparseManaged(i), field2.PointerSparseManaged(i), field3.PointerSparseManaged(i), field4.PointerSparseManaged(i), field5.PointerSparseManaged(i), field6.PointerSparseManaged(i), field7.PointerSparseManaged(i), field8.PointerSparseManaged(i), field9.PointerSparseManaged(i), field10.PointerSparseManaged(i), field11.PointerSparseManaged(i), field12.PointerSparseManaged(i), field13.PointerSparseManaged(i), field14.PointerSparseManaged(i), field15.PointerSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, T14*, T15*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSparseSharedManaged(i), field1.PointerSparseSharedManaged(i), field2.PointerSparseSharedManaged(i), field3.PointerSparseSharedManaged(i), field4.PointerSparseSharedManaged(i), field5.PointerSparseSharedManaged(i), field6.PointerSparseSharedManaged(i), field7.PointerSparseSharedManaged(i), field8.PointerSparseSharedManaged(i), field9.PointerSparseSharedManaged(i), field10.PointerSparseSharedManaged(i), field11.PointerSparseSharedManaged(i), field12.PointerSparseSharedManaged(i), field13.PointerSparseSharedManaged(i), field14.PointerSparseSharedManaged(i), field15.PointerSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 
     /// <summary>
@@ -327,25 +1429,135 @@ public static Entity Find<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
     {
         int count = it.Handle->count; Ecs.Assert(it.Handle->count > 0, "No entities returned, use Iter() or Each() without the entity argument instead.");
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8); byte* pointer9 = (byte*)it.GetPointer<T9>(9); byte* pointer10 = (byte*)it.GetPointer<T10>(10); byte* pointer11 = (byte*)it.GetPointer<T11>(11); byte* pointer12 = (byte*)it.GetPointer<T12>(12); byte* pointer13 = (byte*)it.GetPointer<T13>(13); byte* pointer14 = (byte*)it.GetPointer<T14>(14); byte* pointer15 = (byte*)it.GetPointer<T15>(15);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8); int step9 = it.Step<T9>(9); int step10 = it.Step<T10>(10); int step11 = it.Step<T11>(11); int step12 = it.Step<T12>(12); int step13 = it.Step<T13>(13); int step14 = it.Step<T14>(14); int step15 = it.Step<T15>(15);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8); FieldData<T9> field9 = it.GetFieldData<T9>(9); FieldData<T10> field10 = it.GetFieldData<T10>(10); FieldData<T11> field11 = it.GetFieldData<T11>(11); FieldData<T12> field12 = it.GetFieldData<T12>(12); FieldData<T13> field13 = it.GetFieldData<T13>(13); FieldData<T14> field14 = it.GetFieldData<T14>(14); FieldData<T15> field15 = it.GetFieldData<T15>(15);
+        IterationTechnique flags = it.GetIterationTechnique(16);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8], pointer9 = &pointer9[step9], pointer10 = &pointer10[step10], pointer11 = &pointer11[step11], pointer12 = &pointer12[step12], pointer13 = &pointer13[step13], pointer14 = &pointer14[step14], pointer15 = &pointer15[step15])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>() || RuntimeHelpers.IsReferenceOrContainsReferences<T9>() || RuntimeHelpers.IsReferenceOrContainsReferences<T10>() || RuntimeHelpers.IsReferenceOrContainsReferences<T11>() || RuntimeHelpers.IsReferenceOrContainsReferences<T12>() || RuntimeHelpers.IsReferenceOrContainsReferences<T13>() || RuntimeHelpers.IsReferenceOrContainsReferences<T14>() || RuntimeHelpers.IsReferenceOrContainsReferences<T15>())
         {
-            if (!callback(new Entity(it.Handle->world, it.Handle->entities[i]), (T0*)pointer0, (T1*)pointer1, (T2*)pointer2, (T3*)pointer3, (T4*)pointer4, (T5*)pointer5, (T6*)pointer6, (T7*)pointer7, (T8*)pointer8, (T9*)pointer9, (T10*)pointer10, (T11*)pointer11, (T12*)pointer12, (T13*)pointer13, (T14*)pointer14, (T15*)pointer15))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, T14*, T15*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerUnmanaged(i), field1.PointerUnmanaged(i), field2.PointerUnmanaged(i), field3.PointerUnmanaged(i), field4.PointerUnmanaged(i), field5.PointerUnmanaged(i), field6.PointerUnmanaged(i), field7.PointerUnmanaged(i), field8.PointerUnmanaged(i), field9.PointerUnmanaged(i), field10.PointerUnmanaged(i), field11.PointerUnmanaged(i), field12.PointerUnmanaged(i), field13.PointerUnmanaged(i), field14.PointerUnmanaged(i), field15.PointerUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, T14*, T15*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSharedUnmanaged(i), field1.PointerSharedUnmanaged(i), field2.PointerSharedUnmanaged(i), field3.PointerSharedUnmanaged(i), field4.PointerSharedUnmanaged(i), field5.PointerSharedUnmanaged(i), field6.PointerSharedUnmanaged(i), field7.PointerSharedUnmanaged(i), field8.PointerSharedUnmanaged(i), field9.PointerSharedUnmanaged(i), field10.PointerSharedUnmanaged(i), field11.PointerSharedUnmanaged(i), field12.PointerSharedUnmanaged(i), field13.PointerSharedUnmanaged(i), field14.PointerSharedUnmanaged(i), field15.PointerSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, T14*, T15*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseUnmanaged(i), field1.PointerSparseUnmanaged(i), field2.PointerSparseUnmanaged(i), field3.PointerSparseUnmanaged(i), field4.PointerSparseUnmanaged(i), field5.PointerSparseUnmanaged(i), field6.PointerSparseUnmanaged(i), field7.PointerSparseUnmanaged(i), field8.PointerSparseUnmanaged(i), field9.PointerSparseUnmanaged(i), field10.PointerSparseUnmanaged(i), field11.PointerSparseUnmanaged(i), field12.PointerSparseUnmanaged(i), field13.PointerSparseUnmanaged(i), field14.PointerSparseUnmanaged(i), field15.PointerSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, T14*, T15*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseSharedUnmanaged(i), field1.PointerSparseSharedUnmanaged(i), field2.PointerSparseSharedUnmanaged(i), field3.PointerSparseSharedUnmanaged(i), field4.PointerSparseSharedUnmanaged(i), field5.PointerSparseSharedUnmanaged(i), field6.PointerSparseSharedUnmanaged(i), field7.PointerSparseSharedUnmanaged(i), field8.PointerSparseSharedUnmanaged(i), field9.PointerSparseSharedUnmanaged(i), field10.PointerSparseSharedUnmanaged(i), field11.PointerSparseSharedUnmanaged(i), field12.PointerSparseSharedUnmanaged(i), field13.PointerSparseSharedUnmanaged(i), field14.PointerSparseSharedUnmanaged(i), field15.PointerSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, T14*, T15*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerManaged(i), field1.PointerManaged(i), field2.PointerManaged(i), field3.PointerManaged(i), field4.PointerManaged(i), field5.PointerManaged(i), field6.PointerManaged(i), field7.PointerManaged(i), field8.PointerManaged(i), field9.PointerManaged(i), field10.PointerManaged(i), field11.PointerManaged(i), field12.PointerManaged(i), field13.PointerManaged(i), field14.PointerManaged(i), field15.PointerManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, T14*, T15*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSharedManaged(i), field1.PointerSharedManaged(i), field2.PointerSharedManaged(i), field3.PointerSharedManaged(i), field4.PointerSharedManaged(i), field5.PointerSharedManaged(i), field6.PointerSharedManaged(i), field7.PointerSharedManaged(i), field8.PointerSharedManaged(i), field9.PointerSharedManaged(i), field10.PointerSharedManaged(i), field11.PointerSharedManaged(i), field12.PointerSharedManaged(i), field13.PointerSharedManaged(i), field14.PointerSharedManaged(i), field15.PointerSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, T14*, T15*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseManaged(i), field1.PointerSparseManaged(i), field2.PointerSparseManaged(i), field3.PointerSparseManaged(i), field4.PointerSparseManaged(i), field5.PointerSparseManaged(i), field6.PointerSparseManaged(i), field7.PointerSparseManaged(i), field8.PointerSparseManaged(i), field9.PointerSparseManaged(i), field10.PointerSparseManaged(i), field11.PointerSparseManaged(i), field12.PointerSparseManaged(i), field13.PointerSparseManaged(i), field14.PointerSparseManaged(i), field15.PointerSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, T14*, T15*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseSharedManaged(i), field1.PointerSparseSharedManaged(i), field2.PointerSparseSharedManaged(i), field3.PointerSparseSharedManaged(i), field4.PointerSparseSharedManaged(i), field5.PointerSparseSharedManaged(i), field6.PointerSparseSharedManaged(i), field7.PointerSparseSharedManaged(i), field8.PointerSparseSharedManaged(i), field9.PointerSparseSharedManaged(i), field10.PointerSparseSharedManaged(i), field11.PointerSparseSharedManaged(i), field12.PointerSparseSharedManaged(i), field13.PointerSparseSharedManaged(i), field14.PointerSparseSharedManaged(i), field15.PointerSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 
     /// <summary>
@@ -358,24 +1570,134 @@ public static Entity Find<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8); byte* pointer9 = (byte*)it.GetPointer<T9>(9); byte* pointer10 = (byte*)it.GetPointer<T10>(10); byte* pointer11 = (byte*)it.GetPointer<T11>(11); byte* pointer12 = (byte*)it.GetPointer<T12>(12); byte* pointer13 = (byte*)it.GetPointer<T13>(13); byte* pointer14 = (byte*)it.GetPointer<T14>(14); byte* pointer15 = (byte*)it.GetPointer<T15>(15);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8); int step9 = it.Step<T9>(9); int step10 = it.Step<T10>(10); int step11 = it.Step<T11>(11); int step12 = it.Step<T12>(12); int step13 = it.Step<T13>(13); int step14 = it.Step<T14>(14); int step15 = it.Step<T15>(15);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8); FieldData<T9> field9 = it.GetFieldData<T9>(9); FieldData<T10> field10 = it.GetFieldData<T10>(10); FieldData<T11> field11 = it.GetFieldData<T11>(11); FieldData<T12> field12 = it.GetFieldData<T12>(12); FieldData<T13> field13 = it.GetFieldData<T13>(13); FieldData<T14> field14 = it.GetFieldData<T14>(14); FieldData<T15> field15 = it.GetFieldData<T15>(15);
+        IterationTechnique flags = it.GetIterationTechnique(16);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8], pointer9 = &pointer9[step9], pointer10 = &pointer10[step10], pointer11 = &pointer11[step11], pointer12 = &pointer12[step12], pointer13 = &pointer13[step13], pointer14 = &pointer14[step14], pointer15 = &pointer15[step15])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>() || RuntimeHelpers.IsReferenceOrContainsReferences<T9>() || RuntimeHelpers.IsReferenceOrContainsReferences<T10>() || RuntimeHelpers.IsReferenceOrContainsReferences<T11>() || RuntimeHelpers.IsReferenceOrContainsReferences<T12>() || RuntimeHelpers.IsReferenceOrContainsReferences<T13>() || RuntimeHelpers.IsReferenceOrContainsReferences<T14>() || RuntimeHelpers.IsReferenceOrContainsReferences<T15>())
         {
-            if (!callback(it, i, (T0*)pointer0, (T1*)pointer1, (T2*)pointer2, (T3*)pointer3, (T4*)pointer4, (T5*)pointer5, (T6*)pointer6, (T7*)pointer7, (T8*)pointer8, (T9*)pointer9, (T10*)pointer10, (T11*)pointer11, (T12*)pointer12, (T13*)pointer13, (T14*)pointer14, (T15*)pointer15))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8, ref field9, ref field10, ref field11, ref field12, ref field13, ref field14, ref field15);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, T14*, T15*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerUnmanaged(i), field1.PointerUnmanaged(i), field2.PointerUnmanaged(i), field3.PointerUnmanaged(i), field4.PointerUnmanaged(i), field5.PointerUnmanaged(i), field6.PointerUnmanaged(i), field7.PointerUnmanaged(i), field8.PointerUnmanaged(i), field9.PointerUnmanaged(i), field10.PointerUnmanaged(i), field11.PointerUnmanaged(i), field12.PointerUnmanaged(i), field13.PointerUnmanaged(i), field14.PointerUnmanaged(i), field15.PointerUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, T14*, T15*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSharedUnmanaged(i), field1.PointerSharedUnmanaged(i), field2.PointerSharedUnmanaged(i), field3.PointerSharedUnmanaged(i), field4.PointerSharedUnmanaged(i), field5.PointerSharedUnmanaged(i), field6.PointerSharedUnmanaged(i), field7.PointerSharedUnmanaged(i), field8.PointerSharedUnmanaged(i), field9.PointerSharedUnmanaged(i), field10.PointerSharedUnmanaged(i), field11.PointerSharedUnmanaged(i), field12.PointerSharedUnmanaged(i), field13.PointerSharedUnmanaged(i), field14.PointerSharedUnmanaged(i), field15.PointerSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, T14*, T15*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSparseUnmanaged(i), field1.PointerSparseUnmanaged(i), field2.PointerSparseUnmanaged(i), field3.PointerSparseUnmanaged(i), field4.PointerSparseUnmanaged(i), field5.PointerSparseUnmanaged(i), field6.PointerSparseUnmanaged(i), field7.PointerSparseUnmanaged(i), field8.PointerSparseUnmanaged(i), field9.PointerSparseUnmanaged(i), field10.PointerSparseUnmanaged(i), field11.PointerSparseUnmanaged(i), field12.PointerSparseUnmanaged(i), field13.PointerSparseUnmanaged(i), field14.PointerSparseUnmanaged(i), field15.PointerSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, T14*, T15*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSparseSharedUnmanaged(i), field1.PointerSparseSharedUnmanaged(i), field2.PointerSparseSharedUnmanaged(i), field3.PointerSparseSharedUnmanaged(i), field4.PointerSparseSharedUnmanaged(i), field5.PointerSparseSharedUnmanaged(i), field6.PointerSparseSharedUnmanaged(i), field7.PointerSparseSharedUnmanaged(i), field8.PointerSparseSharedUnmanaged(i), field9.PointerSparseSharedUnmanaged(i), field10.PointerSparseSharedUnmanaged(i), field11.PointerSparseSharedUnmanaged(i), field12.PointerSparseSharedUnmanaged(i), field13.PointerSparseSharedUnmanaged(i), field14.PointerSparseSharedUnmanaged(i), field15.PointerSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, T14*, T15*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerManaged(i), field1.PointerManaged(i), field2.PointerManaged(i), field3.PointerManaged(i), field4.PointerManaged(i), field5.PointerManaged(i), field6.PointerManaged(i), field7.PointerManaged(i), field8.PointerManaged(i), field9.PointerManaged(i), field10.PointerManaged(i), field11.PointerManaged(i), field12.PointerManaged(i), field13.PointerManaged(i), field14.PointerManaged(i), field15.PointerManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, T14*, T15*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSharedManaged(i), field1.PointerSharedManaged(i), field2.PointerSharedManaged(i), field3.PointerSharedManaged(i), field4.PointerSharedManaged(i), field5.PointerSharedManaged(i), field6.PointerSharedManaged(i), field7.PointerSharedManaged(i), field8.PointerSharedManaged(i), field9.PointerSharedManaged(i), field10.PointerSharedManaged(i), field11.PointerSharedManaged(i), field12.PointerSharedManaged(i), field13.PointerSharedManaged(i), field14.PointerSharedManaged(i), field15.PointerSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, T14*, T15*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSparseManaged(i), field1.PointerSparseManaged(i), field2.PointerSparseManaged(i), field3.PointerSparseManaged(i), field4.PointerSparseManaged(i), field5.PointerSparseManaged(i), field6.PointerSparseManaged(i), field7.PointerSparseManaged(i), field8.PointerSparseManaged(i), field9.PointerSparseManaged(i), field10.PointerSparseManaged(i), field11.PointerSparseManaged(i), field12.PointerSparseManaged(i), field13.PointerSparseManaged(i), field14.PointerSparseManaged(i), field15.PointerSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, T14*, T15*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8, ref FieldData<T9> field9, ref FieldData<T10> field10, ref FieldData<T11> field11, ref FieldData<T12> field12, ref FieldData<T13> field13, ref FieldData<T14> field14, ref FieldData<T15> field15)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSparseSharedManaged(i), field1.PointerSparseSharedManaged(i), field2.PointerSparseSharedManaged(i), field3.PointerSparseSharedManaged(i), field4.PointerSparseSharedManaged(i), field5.PointerSparseSharedManaged(i), field6.PointerSparseSharedManaged(i), field7.PointerSparseSharedManaged(i), field8.PointerSparseSharedManaged(i), field9.PointerSparseSharedManaged(i), field10.PointerSparseSharedManaged(i), field11.PointerSparseSharedManaged(i), field12.PointerSparseSharedManaged(i), field13.PointerSparseSharedManaged(i), field14.PointerSparseSharedManaged(i), field15.PointerSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 }
\ No newline at end of file
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/Invoker/Find/Iterator/T2.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/Invoker/Find/Iterator/T2.g.cs
index ba881258..93490c09 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/Invoker/Find/Iterator/T2.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/Invoker/Find/Iterator/T2.g.cs
@@ -1,5 +1,7 @@
 // Find/Iterator/T2.g.cs
 // File was auto-generated by /_/src/Flecs.NET.Codegen/Generators/Invoker.cs
+using System;
+using System.Runtime.CompilerServices;
 using Flecs.NET.Utilities;
 using static Flecs.NET.Bindings.flecs;
 
@@ -17,25 +19,135 @@ public static Entity Find<T0, T1>(Iter it, Ecs.FindRefCallback<T0, T1> callback)
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1);
+        IterationTechnique flags = it.GetIterationTechnique(2);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>())
         {
-            if (!callback(ref Managed.GetTypeRef<T0>(pointer0), ref Managed.GetTypeRef<T1>(pointer1)))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0, ref field1);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0, ref field1);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0, ref field1);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0, ref field1);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0, ref field1);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0, ref field1);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0, ref field1);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0, ref field1);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, Ecs.FindRefCallback<T0, T1> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefUnmanaged(i), ref field1.RefUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, Ecs.FindRefCallback<T0, T1> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSharedUnmanaged(i), ref field1.RefSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, Ecs.FindRefCallback<T0, T1> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSparseUnmanaged(i), ref field1.RefSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, Ecs.FindRefCallback<T0, T1> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSparseSharedUnmanaged(i), ref field1.RefSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, Ecs.FindRefCallback<T0, T1> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefManaged(i), ref field1.RefManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, Ecs.FindRefCallback<T0, T1> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSharedManaged(i), ref field1.RefSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, Ecs.FindRefCallback<T0, T1> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSparseManaged(i), ref field1.RefSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, Ecs.FindRefCallback<T0, T1> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSparseSharedManaged(i), ref field1.RefSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 
     /// <summary>
@@ -48,25 +160,135 @@ public static Entity Find<T0, T1>(Iter it, Ecs.FindEntityRefCallback<T0, T1> cal
     {
         int count = it.Handle->count; Ecs.Assert(it.Handle->count > 0, "No entities returned, use Iter() or Each() without the entity argument instead.");
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1);
+        IterationTechnique flags = it.GetIterationTechnique(2);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>())
         {
-            if (!callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref Managed.GetTypeRef<T0>(pointer0), ref Managed.GetTypeRef<T1>(pointer1)))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0, ref field1);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0, ref field1);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0, ref field1);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0, ref field1);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0, ref field1);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0, ref field1);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0, ref field1);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0, ref field1);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, Ecs.FindEntityRefCallback<T0, T1> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefUnmanaged(i), ref field1.RefUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, Ecs.FindEntityRefCallback<T0, T1> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSharedUnmanaged(i), ref field1.RefSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, Ecs.FindEntityRefCallback<T0, T1> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseUnmanaged(i), ref field1.RefSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, Ecs.FindEntityRefCallback<T0, T1> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseSharedUnmanaged(i), ref field1.RefSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, Ecs.FindEntityRefCallback<T0, T1> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefManaged(i), ref field1.RefManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, Ecs.FindEntityRefCallback<T0, T1> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSharedManaged(i), ref field1.RefSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, Ecs.FindEntityRefCallback<T0, T1> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseManaged(i), ref field1.RefSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, Ecs.FindEntityRefCallback<T0, T1> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseSharedManaged(i), ref field1.RefSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 
     /// <summary>
@@ -79,25 +301,135 @@ public static Entity Find<T0, T1>(Iter it, Ecs.FindIterRefCallback<T0, T1> callb
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1);
+        IterationTechnique flags = it.GetIterationTechnique(2);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>())
         {
-            if (!callback(it, i, ref Managed.GetTypeRef<T0>(pointer0), ref Managed.GetTypeRef<T1>(pointer1)))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0, ref field1);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0, ref field1);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0, ref field1);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0, ref field1);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0, ref field1);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0, ref field1);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0, ref field1);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0, ref field1);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, Ecs.FindIterRefCallback<T0, T1> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefUnmanaged(i), ref field1.RefUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, Ecs.FindIterRefCallback<T0, T1> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSharedUnmanaged(i), ref field1.RefSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, Ecs.FindIterRefCallback<T0, T1> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSparseUnmanaged(i), ref field1.RefSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, Ecs.FindIterRefCallback<T0, T1> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSparseSharedUnmanaged(i), ref field1.RefSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, Ecs.FindIterRefCallback<T0, T1> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefManaged(i), ref field1.RefManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, Ecs.FindIterRefCallback<T0, T1> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSharedManaged(i), ref field1.RefSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, Ecs.FindIterRefCallback<T0, T1> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSparseManaged(i), ref field1.RefSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, Ecs.FindIterRefCallback<T0, T1> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSparseSharedManaged(i), ref field1.RefSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 
     /// <summary>
@@ -110,25 +442,135 @@ public static Entity Find<T0, T1>(Iter it, delegate*<ref T0, ref T1, bool> callb
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1);
+        IterationTechnique flags = it.GetIterationTechnique(2);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>())
         {
-            if (!callback(ref Managed.GetTypeRef<T0>(pointer0), ref Managed.GetTypeRef<T1>(pointer1)))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0, ref field1);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0, ref field1);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0, ref field1);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0, ref field1);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0, ref field1);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0, ref field1);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0, ref field1);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0, ref field1);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, delegate*<ref T0, ref T1, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefUnmanaged(i), ref field1.RefUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, delegate*<ref T0, ref T1, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSharedUnmanaged(i), ref field1.RefSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, delegate*<ref T0, ref T1, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSparseUnmanaged(i), ref field1.RefSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, delegate*<ref T0, ref T1, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSparseSharedUnmanaged(i), ref field1.RefSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, delegate*<ref T0, ref T1, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefManaged(i), ref field1.RefManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, delegate*<ref T0, ref T1, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSharedManaged(i), ref field1.RefSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, delegate*<ref T0, ref T1, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSparseManaged(i), ref field1.RefSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, delegate*<ref T0, ref T1, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSparseSharedManaged(i), ref field1.RefSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 
     /// <summary>
@@ -141,25 +583,135 @@ public static Entity Find<T0, T1>(Iter it, delegate*<Entity, ref T0, ref T1, boo
     {
         int count = it.Handle->count; Ecs.Assert(it.Handle->count > 0, "No entities returned, use Iter() or Each() without the entity argument instead.");
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1);
+        IterationTechnique flags = it.GetIterationTechnique(2);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>())
         {
-            if (!callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref Managed.GetTypeRef<T0>(pointer0), ref Managed.GetTypeRef<T1>(pointer1)))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0, ref field1);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0, ref field1);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0, ref field1);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0, ref field1);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0, ref field1);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0, ref field1);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0, ref field1);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0, ref field1);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefUnmanaged(i), ref field1.RefUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSharedUnmanaged(i), ref field1.RefSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseUnmanaged(i), ref field1.RefSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseSharedUnmanaged(i), ref field1.RefSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, delegate*<Entity, ref T0, ref T1, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefManaged(i), ref field1.RefManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSharedManaged(i), ref field1.RefSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseManaged(i), ref field1.RefSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseSharedManaged(i), ref field1.RefSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 
     /// <summary>
@@ -172,25 +724,135 @@ public static Entity Find<T0, T1>(Iter it, delegate*<Iter, int, ref T0, ref T1,
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1);
+        IterationTechnique flags = it.GetIterationTechnique(2);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>())
         {
-            if (!callback(it, i, ref Managed.GetTypeRef<T0>(pointer0), ref Managed.GetTypeRef<T1>(pointer1)))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0, ref field1);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0, ref field1);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0, ref field1);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0, ref field1);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0, ref field1);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0, ref field1);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0, ref field1);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0, ref field1);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefUnmanaged(i), ref field1.RefUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSharedUnmanaged(i), ref field1.RefSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSparseUnmanaged(i), ref field1.RefSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSparseSharedUnmanaged(i), ref field1.RefSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefManaged(i), ref field1.RefManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSharedManaged(i), ref field1.RefSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSparseManaged(i), ref field1.RefSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSparseSharedManaged(i), ref field1.RefSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 
     /// <summary>
@@ -203,25 +865,135 @@ public static Entity Find<T0, T1>(Iter it, Ecs.FindPointerCallback<T0, T1> callb
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1);
+        IterationTechnique flags = it.GetIterationTechnique(2);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>())
         {
-            if (!callback((T0*)pointer0, (T1*)pointer1))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0, ref field1);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0, ref field1);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0, ref field1);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0, ref field1);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0, ref field1);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0, ref field1);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0, ref field1);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0, ref field1);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, Ecs.FindPointerCallback<T0, T1> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerUnmanaged(i), field1.PointerUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, Ecs.FindPointerCallback<T0, T1> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSharedUnmanaged(i), field1.PointerSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, Ecs.FindPointerCallback<T0, T1> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSparseUnmanaged(i), field1.PointerSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, Ecs.FindPointerCallback<T0, T1> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSparseSharedUnmanaged(i), field1.PointerSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, Ecs.FindPointerCallback<T0, T1> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerManaged(i), field1.PointerManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, Ecs.FindPointerCallback<T0, T1> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSharedManaged(i), field1.PointerSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, Ecs.FindPointerCallback<T0, T1> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSparseManaged(i), field1.PointerSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, Ecs.FindPointerCallback<T0, T1> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSparseSharedManaged(i), field1.PointerSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 
     /// <summary>
@@ -234,25 +1006,135 @@ public static Entity Find<T0, T1>(Iter it, Ecs.FindEntityPointerCallback<T0, T1>
     {
         int count = it.Handle->count; Ecs.Assert(it.Handle->count > 0, "No entities returned, use Iter() or Each() without the entity argument instead.");
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1);
+        IterationTechnique flags = it.GetIterationTechnique(2);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>())
         {
-            if (!callback(new Entity(it.Handle->world, it.Handle->entities[i]), (T0*)pointer0, (T1*)pointer1))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0, ref field1);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0, ref field1);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0, ref field1);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0, ref field1);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0, ref field1);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0, ref field1);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0, ref field1);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0, ref field1);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, Ecs.FindEntityPointerCallback<T0, T1> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerUnmanaged(i), field1.PointerUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, Ecs.FindEntityPointerCallback<T0, T1> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSharedUnmanaged(i), field1.PointerSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, Ecs.FindEntityPointerCallback<T0, T1> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseUnmanaged(i), field1.PointerSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, Ecs.FindEntityPointerCallback<T0, T1> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseSharedUnmanaged(i), field1.PointerSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, Ecs.FindEntityPointerCallback<T0, T1> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerManaged(i), field1.PointerManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, Ecs.FindEntityPointerCallback<T0, T1> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSharedManaged(i), field1.PointerSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, Ecs.FindEntityPointerCallback<T0, T1> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseManaged(i), field1.PointerSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, Ecs.FindEntityPointerCallback<T0, T1> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseSharedManaged(i), field1.PointerSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 
     /// <summary>
@@ -265,25 +1147,135 @@ public static Entity Find<T0, T1>(Iter it, Ecs.FindIterPointerCallback<T0, T1> c
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1);
+        IterationTechnique flags = it.GetIterationTechnique(2);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>())
         {
-            if (!callback(it, i, (T0*)pointer0, (T1*)pointer1))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0, ref field1);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0, ref field1);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0, ref field1);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0, ref field1);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0, ref field1);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0, ref field1);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0, ref field1);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0, ref field1);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, Ecs.FindIterPointerCallback<T0, T1> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerUnmanaged(i), field1.PointerUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, Ecs.FindIterPointerCallback<T0, T1> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSharedUnmanaged(i), field1.PointerSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, Ecs.FindIterPointerCallback<T0, T1> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSparseUnmanaged(i), field1.PointerSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, Ecs.FindIterPointerCallback<T0, T1> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSparseSharedUnmanaged(i), field1.PointerSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, Ecs.FindIterPointerCallback<T0, T1> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerManaged(i), field1.PointerManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, Ecs.FindIterPointerCallback<T0, T1> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSharedManaged(i), field1.PointerSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, Ecs.FindIterPointerCallback<T0, T1> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSparseManaged(i), field1.PointerSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, Ecs.FindIterPointerCallback<T0, T1> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSparseSharedManaged(i), field1.PointerSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 
     /// <summary>
@@ -296,25 +1288,135 @@ public static Entity Find<T0, T1>(Iter it, delegate*<T0*, T1*, bool> callback)
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1);
+        IterationTechnique flags = it.GetIterationTechnique(2);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>())
         {
-            if (!callback((T0*)pointer0, (T1*)pointer1))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0, ref field1);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0, ref field1);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0, ref field1);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0, ref field1);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0, ref field1);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0, ref field1);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0, ref field1);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0, ref field1);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, delegate*<T0*, T1*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerUnmanaged(i), field1.PointerUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, delegate*<T0*, T1*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSharedUnmanaged(i), field1.PointerSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, delegate*<T0*, T1*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSparseUnmanaged(i), field1.PointerSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, delegate*<T0*, T1*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSparseSharedUnmanaged(i), field1.PointerSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, delegate*<T0*, T1*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerManaged(i), field1.PointerManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, delegate*<T0*, T1*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSharedManaged(i), field1.PointerSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, delegate*<T0*, T1*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSparseManaged(i), field1.PointerSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, delegate*<T0*, T1*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSparseSharedManaged(i), field1.PointerSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 
     /// <summary>
@@ -327,25 +1429,135 @@ public static Entity Find<T0, T1>(Iter it, delegate*<Entity, T0*, T1*, bool> cal
     {
         int count = it.Handle->count; Ecs.Assert(it.Handle->count > 0, "No entities returned, use Iter() or Each() without the entity argument instead.");
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1);
+        IterationTechnique flags = it.GetIterationTechnique(2);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>())
         {
-            if (!callback(new Entity(it.Handle->world, it.Handle->entities[i]), (T0*)pointer0, (T1*)pointer1))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0, ref field1);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0, ref field1);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0, ref field1);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0, ref field1);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0, ref field1);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0, ref field1);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0, ref field1);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0, ref field1);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, delegate*<Entity, T0*, T1*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerUnmanaged(i), field1.PointerUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, delegate*<Entity, T0*, T1*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSharedUnmanaged(i), field1.PointerSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, delegate*<Entity, T0*, T1*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseUnmanaged(i), field1.PointerSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, delegate*<Entity, T0*, T1*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseSharedUnmanaged(i), field1.PointerSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, delegate*<Entity, T0*, T1*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerManaged(i), field1.PointerManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, delegate*<Entity, T0*, T1*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSharedManaged(i), field1.PointerSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, delegate*<Entity, T0*, T1*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseManaged(i), field1.PointerSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, delegate*<Entity, T0*, T1*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseSharedManaged(i), field1.PointerSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 
     /// <summary>
@@ -358,24 +1570,134 @@ public static Entity Find<T0, T1>(Iter it, delegate*<Iter, int, T0*, T1*, bool>
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1);
+        IterationTechnique flags = it.GetIterationTechnique(2);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>())
         {
-            if (!callback(it, i, (T0*)pointer0, (T1*)pointer1))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0, ref field1);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0, ref field1);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0, ref field1);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0, ref field1);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0, ref field1);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0, ref field1);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0, ref field1);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0, ref field1);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerUnmanaged(i), field1.PointerUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSharedUnmanaged(i), field1.PointerSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSparseUnmanaged(i), field1.PointerSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSparseSharedUnmanaged(i), field1.PointerSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, delegate*<Iter, int, T0*, T1*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerManaged(i), field1.PointerManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSharedManaged(i), field1.PointerSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSparseManaged(i), field1.PointerSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSparseSharedManaged(i), field1.PointerSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 }
\ No newline at end of file
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/Invoker/Find/Iterator/T3.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/Invoker/Find/Iterator/T3.g.cs
index 70ccfb33..004109da 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/Invoker/Find/Iterator/T3.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/Invoker/Find/Iterator/T3.g.cs
@@ -1,5 +1,7 @@
 // Find/Iterator/T3.g.cs
 // File was auto-generated by /_/src/Flecs.NET.Codegen/Generators/Invoker.cs
+using System;
+using System.Runtime.CompilerServices;
 using Flecs.NET.Utilities;
 using static Flecs.NET.Bindings.flecs;
 
@@ -17,25 +19,135 @@ public static Entity Find<T0, T1, T2>(Iter it, Ecs.FindRefCallback<T0, T1, T2> c
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2);
+        IterationTechnique flags = it.GetIterationTechnique(3);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>())
         {
-            if (!callback(ref Managed.GetTypeRef<T0>(pointer0), ref Managed.GetTypeRef<T1>(pointer1), ref Managed.GetTypeRef<T2>(pointer2)))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0, ref field1, ref field2);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0, ref field1, ref field2);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0, ref field1, ref field2);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0, ref field1, ref field2);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, Ecs.FindRefCallback<T0, T1, T2> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefUnmanaged(i), ref field1.RefUnmanaged(i), ref field2.RefUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, Ecs.FindRefCallback<T0, T1, T2> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSharedUnmanaged(i), ref field1.RefSharedUnmanaged(i), ref field2.RefSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, Ecs.FindRefCallback<T0, T1, T2> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSparseUnmanaged(i), ref field1.RefSparseUnmanaged(i), ref field2.RefSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, Ecs.FindRefCallback<T0, T1, T2> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSparseSharedUnmanaged(i), ref field1.RefSparseSharedUnmanaged(i), ref field2.RefSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, Ecs.FindRefCallback<T0, T1, T2> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefManaged(i), ref field1.RefManaged(i), ref field2.RefManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, Ecs.FindRefCallback<T0, T1, T2> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSharedManaged(i), ref field1.RefSharedManaged(i), ref field2.RefSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, Ecs.FindRefCallback<T0, T1, T2> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSparseManaged(i), ref field1.RefSparseManaged(i), ref field2.RefSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, Ecs.FindRefCallback<T0, T1, T2> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSparseSharedManaged(i), ref field1.RefSparseSharedManaged(i), ref field2.RefSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 
     /// <summary>
@@ -48,25 +160,135 @@ public static Entity Find<T0, T1, T2>(Iter it, Ecs.FindEntityRefCallback<T0, T1,
     {
         int count = it.Handle->count; Ecs.Assert(it.Handle->count > 0, "No entities returned, use Iter() or Each() without the entity argument instead.");
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2);
+        IterationTechnique flags = it.GetIterationTechnique(3);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>())
         {
-            if (!callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref Managed.GetTypeRef<T0>(pointer0), ref Managed.GetTypeRef<T1>(pointer1), ref Managed.GetTypeRef<T2>(pointer2)))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0, ref field1, ref field2);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0, ref field1, ref field2);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0, ref field1, ref field2);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0, ref field1, ref field2);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, Ecs.FindEntityRefCallback<T0, T1, T2> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefUnmanaged(i), ref field1.RefUnmanaged(i), ref field2.RefUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, Ecs.FindEntityRefCallback<T0, T1, T2> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSharedUnmanaged(i), ref field1.RefSharedUnmanaged(i), ref field2.RefSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, Ecs.FindEntityRefCallback<T0, T1, T2> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseUnmanaged(i), ref field1.RefSparseUnmanaged(i), ref field2.RefSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, Ecs.FindEntityRefCallback<T0, T1, T2> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseSharedUnmanaged(i), ref field1.RefSparseSharedUnmanaged(i), ref field2.RefSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, Ecs.FindEntityRefCallback<T0, T1, T2> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefManaged(i), ref field1.RefManaged(i), ref field2.RefManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, Ecs.FindEntityRefCallback<T0, T1, T2> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSharedManaged(i), ref field1.RefSharedManaged(i), ref field2.RefSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, Ecs.FindEntityRefCallback<T0, T1, T2> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseManaged(i), ref field1.RefSparseManaged(i), ref field2.RefSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, Ecs.FindEntityRefCallback<T0, T1, T2> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseSharedManaged(i), ref field1.RefSparseSharedManaged(i), ref field2.RefSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 
     /// <summary>
@@ -79,25 +301,135 @@ public static Entity Find<T0, T1, T2>(Iter it, Ecs.FindIterRefCallback<T0, T1, T
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2);
+        IterationTechnique flags = it.GetIterationTechnique(3);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>())
         {
-            if (!callback(it, i, ref Managed.GetTypeRef<T0>(pointer0), ref Managed.GetTypeRef<T1>(pointer1), ref Managed.GetTypeRef<T2>(pointer2)))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0, ref field1, ref field2);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0, ref field1, ref field2);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0, ref field1, ref field2);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0, ref field1, ref field2);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, Ecs.FindIterRefCallback<T0, T1, T2> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefUnmanaged(i), ref field1.RefUnmanaged(i), ref field2.RefUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, Ecs.FindIterRefCallback<T0, T1, T2> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSharedUnmanaged(i), ref field1.RefSharedUnmanaged(i), ref field2.RefSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, Ecs.FindIterRefCallback<T0, T1, T2> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSparseUnmanaged(i), ref field1.RefSparseUnmanaged(i), ref field2.RefSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, Ecs.FindIterRefCallback<T0, T1, T2> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSparseSharedUnmanaged(i), ref field1.RefSparseSharedUnmanaged(i), ref field2.RefSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, Ecs.FindIterRefCallback<T0, T1, T2> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefManaged(i), ref field1.RefManaged(i), ref field2.RefManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, Ecs.FindIterRefCallback<T0, T1, T2> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSharedManaged(i), ref field1.RefSharedManaged(i), ref field2.RefSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, Ecs.FindIterRefCallback<T0, T1, T2> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSparseManaged(i), ref field1.RefSparseManaged(i), ref field2.RefSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, Ecs.FindIterRefCallback<T0, T1, T2> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSparseSharedManaged(i), ref field1.RefSparseSharedManaged(i), ref field2.RefSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 
     /// <summary>
@@ -110,25 +442,135 @@ public static Entity Find<T0, T1, T2>(Iter it, delegate*<ref T0, ref T1, ref T2,
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2);
+        IterationTechnique flags = it.GetIterationTechnique(3);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>())
         {
-            if (!callback(ref Managed.GetTypeRef<T0>(pointer0), ref Managed.GetTypeRef<T1>(pointer1), ref Managed.GetTypeRef<T2>(pointer2)))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0, ref field1, ref field2);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0, ref field1, ref field2);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0, ref field1, ref field2);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0, ref field1, ref field2);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefUnmanaged(i), ref field1.RefUnmanaged(i), ref field2.RefUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSharedUnmanaged(i), ref field1.RefSharedUnmanaged(i), ref field2.RefSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSparseUnmanaged(i), ref field1.RefSparseUnmanaged(i), ref field2.RefSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSparseSharedUnmanaged(i), ref field1.RefSparseSharedUnmanaged(i), ref field2.RefSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, delegate*<ref T0, ref T1, ref T2, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefManaged(i), ref field1.RefManaged(i), ref field2.RefManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSharedManaged(i), ref field1.RefSharedManaged(i), ref field2.RefSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSparseManaged(i), ref field1.RefSparseManaged(i), ref field2.RefSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSparseSharedManaged(i), ref field1.RefSparseSharedManaged(i), ref field2.RefSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 
     /// <summary>
@@ -141,25 +583,135 @@ public static Entity Find<T0, T1, T2>(Iter it, delegate*<Entity, ref T0, ref T1,
     {
         int count = it.Handle->count; Ecs.Assert(it.Handle->count > 0, "No entities returned, use Iter() or Each() without the entity argument instead.");
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2);
+        IterationTechnique flags = it.GetIterationTechnique(3);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>())
         {
-            if (!callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref Managed.GetTypeRef<T0>(pointer0), ref Managed.GetTypeRef<T1>(pointer1), ref Managed.GetTypeRef<T2>(pointer2)))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0, ref field1, ref field2);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0, ref field1, ref field2);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0, ref field1, ref field2);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0, ref field1, ref field2);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefUnmanaged(i), ref field1.RefUnmanaged(i), ref field2.RefUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSharedUnmanaged(i), ref field1.RefSharedUnmanaged(i), ref field2.RefSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseUnmanaged(i), ref field1.RefSparseUnmanaged(i), ref field2.RefSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseSharedUnmanaged(i), ref field1.RefSparseSharedUnmanaged(i), ref field2.RefSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefManaged(i), ref field1.RefManaged(i), ref field2.RefManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSharedManaged(i), ref field1.RefSharedManaged(i), ref field2.RefSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseManaged(i), ref field1.RefSparseManaged(i), ref field2.RefSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseSharedManaged(i), ref field1.RefSparseSharedManaged(i), ref field2.RefSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 
     /// <summary>
@@ -172,25 +724,135 @@ public static Entity Find<T0, T1, T2>(Iter it, delegate*<Iter, int, ref T0, ref
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2);
+        IterationTechnique flags = it.GetIterationTechnique(3);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>())
         {
-            if (!callback(it, i, ref Managed.GetTypeRef<T0>(pointer0), ref Managed.GetTypeRef<T1>(pointer1), ref Managed.GetTypeRef<T2>(pointer2)))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0, ref field1, ref field2);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0, ref field1, ref field2);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0, ref field1, ref field2);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0, ref field1, ref field2);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefUnmanaged(i), ref field1.RefUnmanaged(i), ref field2.RefUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSharedUnmanaged(i), ref field1.RefSharedUnmanaged(i), ref field2.RefSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSparseUnmanaged(i), ref field1.RefSparseUnmanaged(i), ref field2.RefSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSparseSharedUnmanaged(i), ref field1.RefSparseSharedUnmanaged(i), ref field2.RefSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefManaged(i), ref field1.RefManaged(i), ref field2.RefManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSharedManaged(i), ref field1.RefSharedManaged(i), ref field2.RefSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSparseManaged(i), ref field1.RefSparseManaged(i), ref field2.RefSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSparseSharedManaged(i), ref field1.RefSparseSharedManaged(i), ref field2.RefSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 
     /// <summary>
@@ -203,25 +865,135 @@ public static Entity Find<T0, T1, T2>(Iter it, Ecs.FindPointerCallback<T0, T1, T
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2);
+        IterationTechnique flags = it.GetIterationTechnique(3);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>())
         {
-            if (!callback((T0*)pointer0, (T1*)pointer1, (T2*)pointer2))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0, ref field1, ref field2);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0, ref field1, ref field2);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0, ref field1, ref field2);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0, ref field1, ref field2);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, Ecs.FindPointerCallback<T0, T1, T2> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerUnmanaged(i), field1.PointerUnmanaged(i), field2.PointerUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, Ecs.FindPointerCallback<T0, T1, T2> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSharedUnmanaged(i), field1.PointerSharedUnmanaged(i), field2.PointerSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, Ecs.FindPointerCallback<T0, T1, T2> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSparseUnmanaged(i), field1.PointerSparseUnmanaged(i), field2.PointerSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, Ecs.FindPointerCallback<T0, T1, T2> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSparseSharedUnmanaged(i), field1.PointerSparseSharedUnmanaged(i), field2.PointerSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, Ecs.FindPointerCallback<T0, T1, T2> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerManaged(i), field1.PointerManaged(i), field2.PointerManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, Ecs.FindPointerCallback<T0, T1, T2> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSharedManaged(i), field1.PointerSharedManaged(i), field2.PointerSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, Ecs.FindPointerCallback<T0, T1, T2> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSparseManaged(i), field1.PointerSparseManaged(i), field2.PointerSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, Ecs.FindPointerCallback<T0, T1, T2> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSparseSharedManaged(i), field1.PointerSparseSharedManaged(i), field2.PointerSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 
     /// <summary>
@@ -234,25 +1006,135 @@ public static Entity Find<T0, T1, T2>(Iter it, Ecs.FindEntityPointerCallback<T0,
     {
         int count = it.Handle->count; Ecs.Assert(it.Handle->count > 0, "No entities returned, use Iter() or Each() without the entity argument instead.");
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2);
+        IterationTechnique flags = it.GetIterationTechnique(3);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>())
         {
-            if (!callback(new Entity(it.Handle->world, it.Handle->entities[i]), (T0*)pointer0, (T1*)pointer1, (T2*)pointer2))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0, ref field1, ref field2);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0, ref field1, ref field2);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0, ref field1, ref field2);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0, ref field1, ref field2);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, Ecs.FindEntityPointerCallback<T0, T1, T2> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerUnmanaged(i), field1.PointerUnmanaged(i), field2.PointerUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, Ecs.FindEntityPointerCallback<T0, T1, T2> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSharedUnmanaged(i), field1.PointerSharedUnmanaged(i), field2.PointerSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, Ecs.FindEntityPointerCallback<T0, T1, T2> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseUnmanaged(i), field1.PointerSparseUnmanaged(i), field2.PointerSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, Ecs.FindEntityPointerCallback<T0, T1, T2> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseSharedUnmanaged(i), field1.PointerSparseSharedUnmanaged(i), field2.PointerSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, Ecs.FindEntityPointerCallback<T0, T1, T2> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerManaged(i), field1.PointerManaged(i), field2.PointerManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, Ecs.FindEntityPointerCallback<T0, T1, T2> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSharedManaged(i), field1.PointerSharedManaged(i), field2.PointerSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, Ecs.FindEntityPointerCallback<T0, T1, T2> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseManaged(i), field1.PointerSparseManaged(i), field2.PointerSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, Ecs.FindEntityPointerCallback<T0, T1, T2> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseSharedManaged(i), field1.PointerSparseSharedManaged(i), field2.PointerSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 
     /// <summary>
@@ -265,25 +1147,135 @@ public static Entity Find<T0, T1, T2>(Iter it, Ecs.FindIterPointerCallback<T0, T
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2);
+        IterationTechnique flags = it.GetIterationTechnique(3);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>())
         {
-            if (!callback(it, i, (T0*)pointer0, (T1*)pointer1, (T2*)pointer2))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0, ref field1, ref field2);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0, ref field1, ref field2);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0, ref field1, ref field2);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0, ref field1, ref field2);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, Ecs.FindIterPointerCallback<T0, T1, T2> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerUnmanaged(i), field1.PointerUnmanaged(i), field2.PointerUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, Ecs.FindIterPointerCallback<T0, T1, T2> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSharedUnmanaged(i), field1.PointerSharedUnmanaged(i), field2.PointerSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, Ecs.FindIterPointerCallback<T0, T1, T2> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSparseUnmanaged(i), field1.PointerSparseUnmanaged(i), field2.PointerSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, Ecs.FindIterPointerCallback<T0, T1, T2> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSparseSharedUnmanaged(i), field1.PointerSparseSharedUnmanaged(i), field2.PointerSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, Ecs.FindIterPointerCallback<T0, T1, T2> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerManaged(i), field1.PointerManaged(i), field2.PointerManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, Ecs.FindIterPointerCallback<T0, T1, T2> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSharedManaged(i), field1.PointerSharedManaged(i), field2.PointerSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, Ecs.FindIterPointerCallback<T0, T1, T2> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSparseManaged(i), field1.PointerSparseManaged(i), field2.PointerSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, Ecs.FindIterPointerCallback<T0, T1, T2> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSparseSharedManaged(i), field1.PointerSparseSharedManaged(i), field2.PointerSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 
     /// <summary>
@@ -296,25 +1288,135 @@ public static Entity Find<T0, T1, T2>(Iter it, delegate*<T0*, T1*, T2*, bool> ca
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2);
+        IterationTechnique flags = it.GetIterationTechnique(3);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>())
         {
-            if (!callback((T0*)pointer0, (T1*)pointer1, (T2*)pointer2))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0, ref field1, ref field2);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0, ref field1, ref field2);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0, ref field1, ref field2);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0, ref field1, ref field2);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, delegate*<T0*, T1*, T2*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerUnmanaged(i), field1.PointerUnmanaged(i), field2.PointerUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, delegate*<T0*, T1*, T2*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSharedUnmanaged(i), field1.PointerSharedUnmanaged(i), field2.PointerSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, delegate*<T0*, T1*, T2*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSparseUnmanaged(i), field1.PointerSparseUnmanaged(i), field2.PointerSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, delegate*<T0*, T1*, T2*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSparseSharedUnmanaged(i), field1.PointerSparseSharedUnmanaged(i), field2.PointerSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, delegate*<T0*, T1*, T2*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerManaged(i), field1.PointerManaged(i), field2.PointerManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, delegate*<T0*, T1*, T2*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSharedManaged(i), field1.PointerSharedManaged(i), field2.PointerSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, delegate*<T0*, T1*, T2*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSparseManaged(i), field1.PointerSparseManaged(i), field2.PointerSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, delegate*<T0*, T1*, T2*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSparseSharedManaged(i), field1.PointerSparseSharedManaged(i), field2.PointerSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 
     /// <summary>
@@ -327,25 +1429,135 @@ public static Entity Find<T0, T1, T2>(Iter it, delegate*<Entity, T0*, T1*, T2*,
     {
         int count = it.Handle->count; Ecs.Assert(it.Handle->count > 0, "No entities returned, use Iter() or Each() without the entity argument instead.");
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2);
+        IterationTechnique flags = it.GetIterationTechnique(3);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>())
         {
-            if (!callback(new Entity(it.Handle->world, it.Handle->entities[i]), (T0*)pointer0, (T1*)pointer1, (T2*)pointer2))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0, ref field1, ref field2);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0, ref field1, ref field2);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0, ref field1, ref field2);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0, ref field1, ref field2);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerUnmanaged(i), field1.PointerUnmanaged(i), field2.PointerUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSharedUnmanaged(i), field1.PointerSharedUnmanaged(i), field2.PointerSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseUnmanaged(i), field1.PointerSparseUnmanaged(i), field2.PointerSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseSharedUnmanaged(i), field1.PointerSparseSharedUnmanaged(i), field2.PointerSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerManaged(i), field1.PointerManaged(i), field2.PointerManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSharedManaged(i), field1.PointerSharedManaged(i), field2.PointerSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseManaged(i), field1.PointerSparseManaged(i), field2.PointerSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseSharedManaged(i), field1.PointerSparseSharedManaged(i), field2.PointerSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 
     /// <summary>
@@ -358,24 +1570,134 @@ public static Entity Find<T0, T1, T2>(Iter it, delegate*<Iter, int, T0*, T1*, T2
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2);
+        IterationTechnique flags = it.GetIterationTechnique(3);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>())
         {
-            if (!callback(it, i, (T0*)pointer0, (T1*)pointer1, (T2*)pointer2))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0, ref field1, ref field2);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0, ref field1, ref field2);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0, ref field1, ref field2);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0, ref field1, ref field2);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerUnmanaged(i), field1.PointerUnmanaged(i), field2.PointerUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSharedUnmanaged(i), field1.PointerSharedUnmanaged(i), field2.PointerSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSparseUnmanaged(i), field1.PointerSparseUnmanaged(i), field2.PointerSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSparseSharedUnmanaged(i), field1.PointerSparseSharedUnmanaged(i), field2.PointerSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerManaged(i), field1.PointerManaged(i), field2.PointerManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSharedManaged(i), field1.PointerSharedManaged(i), field2.PointerSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSparseManaged(i), field1.PointerSparseManaged(i), field2.PointerSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSparseSharedManaged(i), field1.PointerSparseSharedManaged(i), field2.PointerSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 }
\ No newline at end of file
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/Invoker/Find/Iterator/T4.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/Invoker/Find/Iterator/T4.g.cs
index f304b0cf..3bad6114 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/Invoker/Find/Iterator/T4.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/Invoker/Find/Iterator/T4.g.cs
@@ -1,5 +1,7 @@
 // Find/Iterator/T4.g.cs
 // File was auto-generated by /_/src/Flecs.NET.Codegen/Generators/Invoker.cs
+using System;
+using System.Runtime.CompilerServices;
 using Flecs.NET.Utilities;
 using static Flecs.NET.Bindings.flecs;
 
@@ -17,25 +19,135 @@ public static Entity Find<T0, T1, T2, T3>(Iter it, Ecs.FindRefCallback<T0, T1, T
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3);
+        IterationTechnique flags = it.GetIterationTechnique(4);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>())
         {
-            if (!callback(ref Managed.GetTypeRef<T0>(pointer0), ref Managed.GetTypeRef<T1>(pointer1), ref Managed.GetTypeRef<T2>(pointer2), ref Managed.GetTypeRef<T3>(pointer3)))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, Ecs.FindRefCallback<T0, T1, T2, T3> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefUnmanaged(i), ref field1.RefUnmanaged(i), ref field2.RefUnmanaged(i), ref field3.RefUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, Ecs.FindRefCallback<T0, T1, T2, T3> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSharedUnmanaged(i), ref field1.RefSharedUnmanaged(i), ref field2.RefSharedUnmanaged(i), ref field3.RefSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, Ecs.FindRefCallback<T0, T1, T2, T3> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSparseUnmanaged(i), ref field1.RefSparseUnmanaged(i), ref field2.RefSparseUnmanaged(i), ref field3.RefSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, Ecs.FindRefCallback<T0, T1, T2, T3> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSparseSharedUnmanaged(i), ref field1.RefSparseSharedUnmanaged(i), ref field2.RefSparseSharedUnmanaged(i), ref field3.RefSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, Ecs.FindRefCallback<T0, T1, T2, T3> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefManaged(i), ref field1.RefManaged(i), ref field2.RefManaged(i), ref field3.RefManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, Ecs.FindRefCallback<T0, T1, T2, T3> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSharedManaged(i), ref field1.RefSharedManaged(i), ref field2.RefSharedManaged(i), ref field3.RefSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, Ecs.FindRefCallback<T0, T1, T2, T3> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSparseManaged(i), ref field1.RefSparseManaged(i), ref field2.RefSparseManaged(i), ref field3.RefSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, Ecs.FindRefCallback<T0, T1, T2, T3> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSparseSharedManaged(i), ref field1.RefSparseSharedManaged(i), ref field2.RefSparseSharedManaged(i), ref field3.RefSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 
     /// <summary>
@@ -48,25 +160,135 @@ public static Entity Find<T0, T1, T2, T3>(Iter it, Ecs.FindEntityRefCallback<T0,
     {
         int count = it.Handle->count; Ecs.Assert(it.Handle->count > 0, "No entities returned, use Iter() or Each() without the entity argument instead.");
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3);
+        IterationTechnique flags = it.GetIterationTechnique(4);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>())
         {
-            if (!callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref Managed.GetTypeRef<T0>(pointer0), ref Managed.GetTypeRef<T1>(pointer1), ref Managed.GetTypeRef<T2>(pointer2), ref Managed.GetTypeRef<T3>(pointer3)))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, Ecs.FindEntityRefCallback<T0, T1, T2, T3> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefUnmanaged(i), ref field1.RefUnmanaged(i), ref field2.RefUnmanaged(i), ref field3.RefUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, Ecs.FindEntityRefCallback<T0, T1, T2, T3> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSharedUnmanaged(i), ref field1.RefSharedUnmanaged(i), ref field2.RefSharedUnmanaged(i), ref field3.RefSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, Ecs.FindEntityRefCallback<T0, T1, T2, T3> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseUnmanaged(i), ref field1.RefSparseUnmanaged(i), ref field2.RefSparseUnmanaged(i), ref field3.RefSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, Ecs.FindEntityRefCallback<T0, T1, T2, T3> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseSharedUnmanaged(i), ref field1.RefSparseSharedUnmanaged(i), ref field2.RefSparseSharedUnmanaged(i), ref field3.RefSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, Ecs.FindEntityRefCallback<T0, T1, T2, T3> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefManaged(i), ref field1.RefManaged(i), ref field2.RefManaged(i), ref field3.RefManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, Ecs.FindEntityRefCallback<T0, T1, T2, T3> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSharedManaged(i), ref field1.RefSharedManaged(i), ref field2.RefSharedManaged(i), ref field3.RefSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, Ecs.FindEntityRefCallback<T0, T1, T2, T3> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseManaged(i), ref field1.RefSparseManaged(i), ref field2.RefSparseManaged(i), ref field3.RefSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, Ecs.FindEntityRefCallback<T0, T1, T2, T3> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseSharedManaged(i), ref field1.RefSparseSharedManaged(i), ref field2.RefSparseSharedManaged(i), ref field3.RefSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 
     /// <summary>
@@ -79,25 +301,135 @@ public static Entity Find<T0, T1, T2, T3>(Iter it, Ecs.FindIterRefCallback<T0, T
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3);
+        IterationTechnique flags = it.GetIterationTechnique(4);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>())
         {
-            if (!callback(it, i, ref Managed.GetTypeRef<T0>(pointer0), ref Managed.GetTypeRef<T1>(pointer1), ref Managed.GetTypeRef<T2>(pointer2), ref Managed.GetTypeRef<T3>(pointer3)))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, Ecs.FindIterRefCallback<T0, T1, T2, T3> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefUnmanaged(i), ref field1.RefUnmanaged(i), ref field2.RefUnmanaged(i), ref field3.RefUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, Ecs.FindIterRefCallback<T0, T1, T2, T3> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSharedUnmanaged(i), ref field1.RefSharedUnmanaged(i), ref field2.RefSharedUnmanaged(i), ref field3.RefSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, Ecs.FindIterRefCallback<T0, T1, T2, T3> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSparseUnmanaged(i), ref field1.RefSparseUnmanaged(i), ref field2.RefSparseUnmanaged(i), ref field3.RefSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, Ecs.FindIterRefCallback<T0, T1, T2, T3> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSparseSharedUnmanaged(i), ref field1.RefSparseSharedUnmanaged(i), ref field2.RefSparseSharedUnmanaged(i), ref field3.RefSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, Ecs.FindIterRefCallback<T0, T1, T2, T3> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefManaged(i), ref field1.RefManaged(i), ref field2.RefManaged(i), ref field3.RefManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, Ecs.FindIterRefCallback<T0, T1, T2, T3> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSharedManaged(i), ref field1.RefSharedManaged(i), ref field2.RefSharedManaged(i), ref field3.RefSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, Ecs.FindIterRefCallback<T0, T1, T2, T3> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSparseManaged(i), ref field1.RefSparseManaged(i), ref field2.RefSparseManaged(i), ref field3.RefSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, Ecs.FindIterRefCallback<T0, T1, T2, T3> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSparseSharedManaged(i), ref field1.RefSparseSharedManaged(i), ref field2.RefSparseSharedManaged(i), ref field3.RefSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 
     /// <summary>
@@ -110,25 +442,135 @@ public static Entity Find<T0, T1, T2, T3>(Iter it, delegate*<ref T0, ref T1, ref
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3);
+        IterationTechnique flags = it.GetIterationTechnique(4);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>())
         {
-            if (!callback(ref Managed.GetTypeRef<T0>(pointer0), ref Managed.GetTypeRef<T1>(pointer1), ref Managed.GetTypeRef<T2>(pointer2), ref Managed.GetTypeRef<T3>(pointer3)))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefUnmanaged(i), ref field1.RefUnmanaged(i), ref field2.RefUnmanaged(i), ref field3.RefUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSharedUnmanaged(i), ref field1.RefSharedUnmanaged(i), ref field2.RefSharedUnmanaged(i), ref field3.RefSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSparseUnmanaged(i), ref field1.RefSparseUnmanaged(i), ref field2.RefSparseUnmanaged(i), ref field3.RefSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSparseSharedUnmanaged(i), ref field1.RefSparseSharedUnmanaged(i), ref field2.RefSparseSharedUnmanaged(i), ref field3.RefSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefManaged(i), ref field1.RefManaged(i), ref field2.RefManaged(i), ref field3.RefManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSharedManaged(i), ref field1.RefSharedManaged(i), ref field2.RefSharedManaged(i), ref field3.RefSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSparseManaged(i), ref field1.RefSparseManaged(i), ref field2.RefSparseManaged(i), ref field3.RefSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSparseSharedManaged(i), ref field1.RefSparseSharedManaged(i), ref field2.RefSparseSharedManaged(i), ref field3.RefSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 
     /// <summary>
@@ -141,25 +583,135 @@ public static Entity Find<T0, T1, T2, T3>(Iter it, delegate*<Entity, ref T0, ref
     {
         int count = it.Handle->count; Ecs.Assert(it.Handle->count > 0, "No entities returned, use Iter() or Each() without the entity argument instead.");
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3);
+        IterationTechnique flags = it.GetIterationTechnique(4);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>())
         {
-            if (!callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref Managed.GetTypeRef<T0>(pointer0), ref Managed.GetTypeRef<T1>(pointer1), ref Managed.GetTypeRef<T2>(pointer2), ref Managed.GetTypeRef<T3>(pointer3)))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefUnmanaged(i), ref field1.RefUnmanaged(i), ref field2.RefUnmanaged(i), ref field3.RefUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSharedUnmanaged(i), ref field1.RefSharedUnmanaged(i), ref field2.RefSharedUnmanaged(i), ref field3.RefSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseUnmanaged(i), ref field1.RefSparseUnmanaged(i), ref field2.RefSparseUnmanaged(i), ref field3.RefSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseSharedUnmanaged(i), ref field1.RefSparseSharedUnmanaged(i), ref field2.RefSparseSharedUnmanaged(i), ref field3.RefSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefManaged(i), ref field1.RefManaged(i), ref field2.RefManaged(i), ref field3.RefManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSharedManaged(i), ref field1.RefSharedManaged(i), ref field2.RefSharedManaged(i), ref field3.RefSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseManaged(i), ref field1.RefSparseManaged(i), ref field2.RefSparseManaged(i), ref field3.RefSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseSharedManaged(i), ref field1.RefSparseSharedManaged(i), ref field2.RefSparseSharedManaged(i), ref field3.RefSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 
     /// <summary>
@@ -172,25 +724,135 @@ public static Entity Find<T0, T1, T2, T3>(Iter it, delegate*<Iter, int, ref T0,
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3);
+        IterationTechnique flags = it.GetIterationTechnique(4);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>())
         {
-            if (!callback(it, i, ref Managed.GetTypeRef<T0>(pointer0), ref Managed.GetTypeRef<T1>(pointer1), ref Managed.GetTypeRef<T2>(pointer2), ref Managed.GetTypeRef<T3>(pointer3)))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefUnmanaged(i), ref field1.RefUnmanaged(i), ref field2.RefUnmanaged(i), ref field3.RefUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSharedUnmanaged(i), ref field1.RefSharedUnmanaged(i), ref field2.RefSharedUnmanaged(i), ref field3.RefSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSparseUnmanaged(i), ref field1.RefSparseUnmanaged(i), ref field2.RefSparseUnmanaged(i), ref field3.RefSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSparseSharedUnmanaged(i), ref field1.RefSparseSharedUnmanaged(i), ref field2.RefSparseSharedUnmanaged(i), ref field3.RefSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefManaged(i), ref field1.RefManaged(i), ref field2.RefManaged(i), ref field3.RefManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSharedManaged(i), ref field1.RefSharedManaged(i), ref field2.RefSharedManaged(i), ref field3.RefSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSparseManaged(i), ref field1.RefSparseManaged(i), ref field2.RefSparseManaged(i), ref field3.RefSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSparseSharedManaged(i), ref field1.RefSparseSharedManaged(i), ref field2.RefSparseSharedManaged(i), ref field3.RefSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 
     /// <summary>
@@ -203,25 +865,135 @@ public static Entity Find<T0, T1, T2, T3>(Iter it, Ecs.FindPointerCallback<T0, T
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3);
+        IterationTechnique flags = it.GetIterationTechnique(4);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>())
         {
-            if (!callback((T0*)pointer0, (T1*)pointer1, (T2*)pointer2, (T3*)pointer3))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, Ecs.FindPointerCallback<T0, T1, T2, T3> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerUnmanaged(i), field1.PointerUnmanaged(i), field2.PointerUnmanaged(i), field3.PointerUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, Ecs.FindPointerCallback<T0, T1, T2, T3> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSharedUnmanaged(i), field1.PointerSharedUnmanaged(i), field2.PointerSharedUnmanaged(i), field3.PointerSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, Ecs.FindPointerCallback<T0, T1, T2, T3> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSparseUnmanaged(i), field1.PointerSparseUnmanaged(i), field2.PointerSparseUnmanaged(i), field3.PointerSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, Ecs.FindPointerCallback<T0, T1, T2, T3> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSparseSharedUnmanaged(i), field1.PointerSparseSharedUnmanaged(i), field2.PointerSparseSharedUnmanaged(i), field3.PointerSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, Ecs.FindPointerCallback<T0, T1, T2, T3> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerManaged(i), field1.PointerManaged(i), field2.PointerManaged(i), field3.PointerManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, Ecs.FindPointerCallback<T0, T1, T2, T3> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSharedManaged(i), field1.PointerSharedManaged(i), field2.PointerSharedManaged(i), field3.PointerSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, Ecs.FindPointerCallback<T0, T1, T2, T3> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSparseManaged(i), field1.PointerSparseManaged(i), field2.PointerSparseManaged(i), field3.PointerSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, Ecs.FindPointerCallback<T0, T1, T2, T3> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSparseSharedManaged(i), field1.PointerSparseSharedManaged(i), field2.PointerSparseSharedManaged(i), field3.PointerSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 
     /// <summary>
@@ -234,25 +1006,135 @@ public static Entity Find<T0, T1, T2, T3>(Iter it, Ecs.FindEntityPointerCallback
     {
         int count = it.Handle->count; Ecs.Assert(it.Handle->count > 0, "No entities returned, use Iter() or Each() without the entity argument instead.");
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3);
+        IterationTechnique flags = it.GetIterationTechnique(4);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>())
         {
-            if (!callback(new Entity(it.Handle->world, it.Handle->entities[i]), (T0*)pointer0, (T1*)pointer1, (T2*)pointer2, (T3*)pointer3))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, Ecs.FindEntityPointerCallback<T0, T1, T2, T3> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerUnmanaged(i), field1.PointerUnmanaged(i), field2.PointerUnmanaged(i), field3.PointerUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, Ecs.FindEntityPointerCallback<T0, T1, T2, T3> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSharedUnmanaged(i), field1.PointerSharedUnmanaged(i), field2.PointerSharedUnmanaged(i), field3.PointerSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, Ecs.FindEntityPointerCallback<T0, T1, T2, T3> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseUnmanaged(i), field1.PointerSparseUnmanaged(i), field2.PointerSparseUnmanaged(i), field3.PointerSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, Ecs.FindEntityPointerCallback<T0, T1, T2, T3> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseSharedUnmanaged(i), field1.PointerSparseSharedUnmanaged(i), field2.PointerSparseSharedUnmanaged(i), field3.PointerSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, Ecs.FindEntityPointerCallback<T0, T1, T2, T3> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerManaged(i), field1.PointerManaged(i), field2.PointerManaged(i), field3.PointerManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, Ecs.FindEntityPointerCallback<T0, T1, T2, T3> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSharedManaged(i), field1.PointerSharedManaged(i), field2.PointerSharedManaged(i), field3.PointerSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, Ecs.FindEntityPointerCallback<T0, T1, T2, T3> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseManaged(i), field1.PointerSparseManaged(i), field2.PointerSparseManaged(i), field3.PointerSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, Ecs.FindEntityPointerCallback<T0, T1, T2, T3> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseSharedManaged(i), field1.PointerSparseSharedManaged(i), field2.PointerSparseSharedManaged(i), field3.PointerSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 
     /// <summary>
@@ -265,25 +1147,135 @@ public static Entity Find<T0, T1, T2, T3>(Iter it, Ecs.FindIterPointerCallback<T
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3);
+        IterationTechnique flags = it.GetIterationTechnique(4);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>())
         {
-            if (!callback(it, i, (T0*)pointer0, (T1*)pointer1, (T2*)pointer2, (T3*)pointer3))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, Ecs.FindIterPointerCallback<T0, T1, T2, T3> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerUnmanaged(i), field1.PointerUnmanaged(i), field2.PointerUnmanaged(i), field3.PointerUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, Ecs.FindIterPointerCallback<T0, T1, T2, T3> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSharedUnmanaged(i), field1.PointerSharedUnmanaged(i), field2.PointerSharedUnmanaged(i), field3.PointerSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, Ecs.FindIterPointerCallback<T0, T1, T2, T3> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSparseUnmanaged(i), field1.PointerSparseUnmanaged(i), field2.PointerSparseUnmanaged(i), field3.PointerSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, Ecs.FindIterPointerCallback<T0, T1, T2, T3> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSparseSharedUnmanaged(i), field1.PointerSparseSharedUnmanaged(i), field2.PointerSparseSharedUnmanaged(i), field3.PointerSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, Ecs.FindIterPointerCallback<T0, T1, T2, T3> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerManaged(i), field1.PointerManaged(i), field2.PointerManaged(i), field3.PointerManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, Ecs.FindIterPointerCallback<T0, T1, T2, T3> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSharedManaged(i), field1.PointerSharedManaged(i), field2.PointerSharedManaged(i), field3.PointerSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, Ecs.FindIterPointerCallback<T0, T1, T2, T3> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSparseManaged(i), field1.PointerSparseManaged(i), field2.PointerSparseManaged(i), field3.PointerSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, Ecs.FindIterPointerCallback<T0, T1, T2, T3> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSparseSharedManaged(i), field1.PointerSparseSharedManaged(i), field2.PointerSparseSharedManaged(i), field3.PointerSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 
     /// <summary>
@@ -296,25 +1288,135 @@ public static Entity Find<T0, T1, T2, T3>(Iter it, delegate*<T0*, T1*, T2*, T3*,
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3);
+        IterationTechnique flags = it.GetIterationTechnique(4);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>())
         {
-            if (!callback((T0*)pointer0, (T1*)pointer1, (T2*)pointer2, (T3*)pointer3))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerUnmanaged(i), field1.PointerUnmanaged(i), field2.PointerUnmanaged(i), field3.PointerUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSharedUnmanaged(i), field1.PointerSharedUnmanaged(i), field2.PointerSharedUnmanaged(i), field3.PointerSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSparseUnmanaged(i), field1.PointerSparseUnmanaged(i), field2.PointerSparseUnmanaged(i), field3.PointerSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSparseSharedUnmanaged(i), field1.PointerSparseSharedUnmanaged(i), field2.PointerSparseSharedUnmanaged(i), field3.PointerSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerManaged(i), field1.PointerManaged(i), field2.PointerManaged(i), field3.PointerManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSharedManaged(i), field1.PointerSharedManaged(i), field2.PointerSharedManaged(i), field3.PointerSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSparseManaged(i), field1.PointerSparseManaged(i), field2.PointerSparseManaged(i), field3.PointerSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSparseSharedManaged(i), field1.PointerSparseSharedManaged(i), field2.PointerSparseSharedManaged(i), field3.PointerSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 
     /// <summary>
@@ -327,25 +1429,135 @@ public static Entity Find<T0, T1, T2, T3>(Iter it, delegate*<Entity, T0*, T1*, T
     {
         int count = it.Handle->count; Ecs.Assert(it.Handle->count > 0, "No entities returned, use Iter() or Each() without the entity argument instead.");
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3);
+        IterationTechnique flags = it.GetIterationTechnique(4);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>())
         {
-            if (!callback(new Entity(it.Handle->world, it.Handle->entities[i]), (T0*)pointer0, (T1*)pointer1, (T2*)pointer2, (T3*)pointer3))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerUnmanaged(i), field1.PointerUnmanaged(i), field2.PointerUnmanaged(i), field3.PointerUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSharedUnmanaged(i), field1.PointerSharedUnmanaged(i), field2.PointerSharedUnmanaged(i), field3.PointerSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseUnmanaged(i), field1.PointerSparseUnmanaged(i), field2.PointerSparseUnmanaged(i), field3.PointerSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseSharedUnmanaged(i), field1.PointerSparseSharedUnmanaged(i), field2.PointerSparseSharedUnmanaged(i), field3.PointerSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerManaged(i), field1.PointerManaged(i), field2.PointerManaged(i), field3.PointerManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSharedManaged(i), field1.PointerSharedManaged(i), field2.PointerSharedManaged(i), field3.PointerSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseManaged(i), field1.PointerSparseManaged(i), field2.PointerSparseManaged(i), field3.PointerSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseSharedManaged(i), field1.PointerSparseSharedManaged(i), field2.PointerSparseSharedManaged(i), field3.PointerSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 
     /// <summary>
@@ -358,24 +1570,134 @@ public static Entity Find<T0, T1, T2, T3>(Iter it, delegate*<Iter, int, T0*, T1*
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3);
+        IterationTechnique flags = it.GetIterationTechnique(4);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>())
         {
-            if (!callback(it, i, (T0*)pointer0, (T1*)pointer1, (T2*)pointer2, (T3*)pointer3))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerUnmanaged(i), field1.PointerUnmanaged(i), field2.PointerUnmanaged(i), field3.PointerUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSharedUnmanaged(i), field1.PointerSharedUnmanaged(i), field2.PointerSharedUnmanaged(i), field3.PointerSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSparseUnmanaged(i), field1.PointerSparseUnmanaged(i), field2.PointerSparseUnmanaged(i), field3.PointerSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSparseSharedUnmanaged(i), field1.PointerSparseSharedUnmanaged(i), field2.PointerSparseSharedUnmanaged(i), field3.PointerSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerManaged(i), field1.PointerManaged(i), field2.PointerManaged(i), field3.PointerManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSharedManaged(i), field1.PointerSharedManaged(i), field2.PointerSharedManaged(i), field3.PointerSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSparseManaged(i), field1.PointerSparseManaged(i), field2.PointerSparseManaged(i), field3.PointerSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSparseSharedManaged(i), field1.PointerSparseSharedManaged(i), field2.PointerSparseSharedManaged(i), field3.PointerSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 }
\ No newline at end of file
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/Invoker/Find/Iterator/T5.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/Invoker/Find/Iterator/T5.g.cs
index 1a3326fd..e3ecb00f 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/Invoker/Find/Iterator/T5.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/Invoker/Find/Iterator/T5.g.cs
@@ -1,5 +1,7 @@
 // Find/Iterator/T5.g.cs
 // File was auto-generated by /_/src/Flecs.NET.Codegen/Generators/Invoker.cs
+using System;
+using System.Runtime.CompilerServices;
 using Flecs.NET.Utilities;
 using static Flecs.NET.Bindings.flecs;
 
@@ -17,25 +19,135 @@ public static Entity Find<T0, T1, T2, T3, T4>(Iter it, Ecs.FindRefCallback<T0, T
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4);
+        IterationTechnique flags = it.GetIterationTechnique(5);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>())
         {
-            if (!callback(ref Managed.GetTypeRef<T0>(pointer0), ref Managed.GetTypeRef<T1>(pointer1), ref Managed.GetTypeRef<T2>(pointer2), ref Managed.GetTypeRef<T3>(pointer3), ref Managed.GetTypeRef<T4>(pointer4)))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, Ecs.FindRefCallback<T0, T1, T2, T3, T4> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefUnmanaged(i), ref field1.RefUnmanaged(i), ref field2.RefUnmanaged(i), ref field3.RefUnmanaged(i), ref field4.RefUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, Ecs.FindRefCallback<T0, T1, T2, T3, T4> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSharedUnmanaged(i), ref field1.RefSharedUnmanaged(i), ref field2.RefSharedUnmanaged(i), ref field3.RefSharedUnmanaged(i), ref field4.RefSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, Ecs.FindRefCallback<T0, T1, T2, T3, T4> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSparseUnmanaged(i), ref field1.RefSparseUnmanaged(i), ref field2.RefSparseUnmanaged(i), ref field3.RefSparseUnmanaged(i), ref field4.RefSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, Ecs.FindRefCallback<T0, T1, T2, T3, T4> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSparseSharedUnmanaged(i), ref field1.RefSparseSharedUnmanaged(i), ref field2.RefSparseSharedUnmanaged(i), ref field3.RefSparseSharedUnmanaged(i), ref field4.RefSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, Ecs.FindRefCallback<T0, T1, T2, T3, T4> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefManaged(i), ref field1.RefManaged(i), ref field2.RefManaged(i), ref field3.RefManaged(i), ref field4.RefManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, Ecs.FindRefCallback<T0, T1, T2, T3, T4> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSharedManaged(i), ref field1.RefSharedManaged(i), ref field2.RefSharedManaged(i), ref field3.RefSharedManaged(i), ref field4.RefSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, Ecs.FindRefCallback<T0, T1, T2, T3, T4> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSparseManaged(i), ref field1.RefSparseManaged(i), ref field2.RefSparseManaged(i), ref field3.RefSparseManaged(i), ref field4.RefSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, Ecs.FindRefCallback<T0, T1, T2, T3, T4> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSparseSharedManaged(i), ref field1.RefSparseSharedManaged(i), ref field2.RefSparseSharedManaged(i), ref field3.RefSparseSharedManaged(i), ref field4.RefSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 
     /// <summary>
@@ -48,25 +160,135 @@ public static Entity Find<T0, T1, T2, T3, T4>(Iter it, Ecs.FindEntityRefCallback
     {
         int count = it.Handle->count; Ecs.Assert(it.Handle->count > 0, "No entities returned, use Iter() or Each() without the entity argument instead.");
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4);
+        IterationTechnique flags = it.GetIterationTechnique(5);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>())
         {
-            if (!callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref Managed.GetTypeRef<T0>(pointer0), ref Managed.GetTypeRef<T1>(pointer1), ref Managed.GetTypeRef<T2>(pointer2), ref Managed.GetTypeRef<T3>(pointer3), ref Managed.GetTypeRef<T4>(pointer4)))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefUnmanaged(i), ref field1.RefUnmanaged(i), ref field2.RefUnmanaged(i), ref field3.RefUnmanaged(i), ref field4.RefUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSharedUnmanaged(i), ref field1.RefSharedUnmanaged(i), ref field2.RefSharedUnmanaged(i), ref field3.RefSharedUnmanaged(i), ref field4.RefSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseUnmanaged(i), ref field1.RefSparseUnmanaged(i), ref field2.RefSparseUnmanaged(i), ref field3.RefSparseUnmanaged(i), ref field4.RefSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseSharedUnmanaged(i), ref field1.RefSparseSharedUnmanaged(i), ref field2.RefSparseSharedUnmanaged(i), ref field3.RefSparseSharedUnmanaged(i), ref field4.RefSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefManaged(i), ref field1.RefManaged(i), ref field2.RefManaged(i), ref field3.RefManaged(i), ref field4.RefManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSharedManaged(i), ref field1.RefSharedManaged(i), ref field2.RefSharedManaged(i), ref field3.RefSharedManaged(i), ref field4.RefSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseManaged(i), ref field1.RefSparseManaged(i), ref field2.RefSparseManaged(i), ref field3.RefSparseManaged(i), ref field4.RefSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseSharedManaged(i), ref field1.RefSparseSharedManaged(i), ref field2.RefSparseSharedManaged(i), ref field3.RefSparseSharedManaged(i), ref field4.RefSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 
     /// <summary>
@@ -79,25 +301,135 @@ public static Entity Find<T0, T1, T2, T3, T4>(Iter it, Ecs.FindIterRefCallback<T
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4);
+        IterationTechnique flags = it.GetIterationTechnique(5);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>())
         {
-            if (!callback(it, i, ref Managed.GetTypeRef<T0>(pointer0), ref Managed.GetTypeRef<T1>(pointer1), ref Managed.GetTypeRef<T2>(pointer2), ref Managed.GetTypeRef<T3>(pointer3), ref Managed.GetTypeRef<T4>(pointer4)))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, Ecs.FindIterRefCallback<T0, T1, T2, T3, T4> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefUnmanaged(i), ref field1.RefUnmanaged(i), ref field2.RefUnmanaged(i), ref field3.RefUnmanaged(i), ref field4.RefUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, Ecs.FindIterRefCallback<T0, T1, T2, T3, T4> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSharedUnmanaged(i), ref field1.RefSharedUnmanaged(i), ref field2.RefSharedUnmanaged(i), ref field3.RefSharedUnmanaged(i), ref field4.RefSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, Ecs.FindIterRefCallback<T0, T1, T2, T3, T4> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSparseUnmanaged(i), ref field1.RefSparseUnmanaged(i), ref field2.RefSparseUnmanaged(i), ref field3.RefSparseUnmanaged(i), ref field4.RefSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, Ecs.FindIterRefCallback<T0, T1, T2, T3, T4> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSparseSharedUnmanaged(i), ref field1.RefSparseSharedUnmanaged(i), ref field2.RefSparseSharedUnmanaged(i), ref field3.RefSparseSharedUnmanaged(i), ref field4.RefSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, Ecs.FindIterRefCallback<T0, T1, T2, T3, T4> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefManaged(i), ref field1.RefManaged(i), ref field2.RefManaged(i), ref field3.RefManaged(i), ref field4.RefManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, Ecs.FindIterRefCallback<T0, T1, T2, T3, T4> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSharedManaged(i), ref field1.RefSharedManaged(i), ref field2.RefSharedManaged(i), ref field3.RefSharedManaged(i), ref field4.RefSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, Ecs.FindIterRefCallback<T0, T1, T2, T3, T4> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSparseManaged(i), ref field1.RefSparseManaged(i), ref field2.RefSparseManaged(i), ref field3.RefSparseManaged(i), ref field4.RefSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, Ecs.FindIterRefCallback<T0, T1, T2, T3, T4> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSparseSharedManaged(i), ref field1.RefSparseSharedManaged(i), ref field2.RefSparseSharedManaged(i), ref field3.RefSparseSharedManaged(i), ref field4.RefSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 
     /// <summary>
@@ -110,25 +442,135 @@ public static Entity Find<T0, T1, T2, T3, T4>(Iter it, delegate*<ref T0, ref T1,
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4);
+        IterationTechnique flags = it.GetIterationTechnique(5);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>())
         {
-            if (!callback(ref Managed.GetTypeRef<T0>(pointer0), ref Managed.GetTypeRef<T1>(pointer1), ref Managed.GetTypeRef<T2>(pointer2), ref Managed.GetTypeRef<T3>(pointer3), ref Managed.GetTypeRef<T4>(pointer4)))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefUnmanaged(i), ref field1.RefUnmanaged(i), ref field2.RefUnmanaged(i), ref field3.RefUnmanaged(i), ref field4.RefUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSharedUnmanaged(i), ref field1.RefSharedUnmanaged(i), ref field2.RefSharedUnmanaged(i), ref field3.RefSharedUnmanaged(i), ref field4.RefSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSparseUnmanaged(i), ref field1.RefSparseUnmanaged(i), ref field2.RefSparseUnmanaged(i), ref field3.RefSparseUnmanaged(i), ref field4.RefSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSparseSharedUnmanaged(i), ref field1.RefSparseSharedUnmanaged(i), ref field2.RefSparseSharedUnmanaged(i), ref field3.RefSparseSharedUnmanaged(i), ref field4.RefSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefManaged(i), ref field1.RefManaged(i), ref field2.RefManaged(i), ref field3.RefManaged(i), ref field4.RefManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSharedManaged(i), ref field1.RefSharedManaged(i), ref field2.RefSharedManaged(i), ref field3.RefSharedManaged(i), ref field4.RefSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSparseManaged(i), ref field1.RefSparseManaged(i), ref field2.RefSparseManaged(i), ref field3.RefSparseManaged(i), ref field4.RefSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSparseSharedManaged(i), ref field1.RefSparseSharedManaged(i), ref field2.RefSparseSharedManaged(i), ref field3.RefSparseSharedManaged(i), ref field4.RefSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 
     /// <summary>
@@ -141,25 +583,135 @@ public static Entity Find<T0, T1, T2, T3, T4>(Iter it, delegate*<Entity, ref T0,
     {
         int count = it.Handle->count; Ecs.Assert(it.Handle->count > 0, "No entities returned, use Iter() or Each() without the entity argument instead.");
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4);
+        IterationTechnique flags = it.GetIterationTechnique(5);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>())
         {
-            if (!callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref Managed.GetTypeRef<T0>(pointer0), ref Managed.GetTypeRef<T1>(pointer1), ref Managed.GetTypeRef<T2>(pointer2), ref Managed.GetTypeRef<T3>(pointer3), ref Managed.GetTypeRef<T4>(pointer4)))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefUnmanaged(i), ref field1.RefUnmanaged(i), ref field2.RefUnmanaged(i), ref field3.RefUnmanaged(i), ref field4.RefUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSharedUnmanaged(i), ref field1.RefSharedUnmanaged(i), ref field2.RefSharedUnmanaged(i), ref field3.RefSharedUnmanaged(i), ref field4.RefSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseUnmanaged(i), ref field1.RefSparseUnmanaged(i), ref field2.RefSparseUnmanaged(i), ref field3.RefSparseUnmanaged(i), ref field4.RefSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseSharedUnmanaged(i), ref field1.RefSparseSharedUnmanaged(i), ref field2.RefSparseSharedUnmanaged(i), ref field3.RefSparseSharedUnmanaged(i), ref field4.RefSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefManaged(i), ref field1.RefManaged(i), ref field2.RefManaged(i), ref field3.RefManaged(i), ref field4.RefManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSharedManaged(i), ref field1.RefSharedManaged(i), ref field2.RefSharedManaged(i), ref field3.RefSharedManaged(i), ref field4.RefSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseManaged(i), ref field1.RefSparseManaged(i), ref field2.RefSparseManaged(i), ref field3.RefSparseManaged(i), ref field4.RefSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseSharedManaged(i), ref field1.RefSparseSharedManaged(i), ref field2.RefSparseSharedManaged(i), ref field3.RefSparseSharedManaged(i), ref field4.RefSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 
     /// <summary>
@@ -172,25 +724,135 @@ public static Entity Find<T0, T1, T2, T3, T4>(Iter it, delegate*<Iter, int, ref
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4);
+        IterationTechnique flags = it.GetIterationTechnique(5);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>())
         {
-            if (!callback(it, i, ref Managed.GetTypeRef<T0>(pointer0), ref Managed.GetTypeRef<T1>(pointer1), ref Managed.GetTypeRef<T2>(pointer2), ref Managed.GetTypeRef<T3>(pointer3), ref Managed.GetTypeRef<T4>(pointer4)))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefUnmanaged(i), ref field1.RefUnmanaged(i), ref field2.RefUnmanaged(i), ref field3.RefUnmanaged(i), ref field4.RefUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSharedUnmanaged(i), ref field1.RefSharedUnmanaged(i), ref field2.RefSharedUnmanaged(i), ref field3.RefSharedUnmanaged(i), ref field4.RefSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSparseUnmanaged(i), ref field1.RefSparseUnmanaged(i), ref field2.RefSparseUnmanaged(i), ref field3.RefSparseUnmanaged(i), ref field4.RefSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSparseSharedUnmanaged(i), ref field1.RefSparseSharedUnmanaged(i), ref field2.RefSparseSharedUnmanaged(i), ref field3.RefSparseSharedUnmanaged(i), ref field4.RefSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefManaged(i), ref field1.RefManaged(i), ref field2.RefManaged(i), ref field3.RefManaged(i), ref field4.RefManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSharedManaged(i), ref field1.RefSharedManaged(i), ref field2.RefSharedManaged(i), ref field3.RefSharedManaged(i), ref field4.RefSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSparseManaged(i), ref field1.RefSparseManaged(i), ref field2.RefSparseManaged(i), ref field3.RefSparseManaged(i), ref field4.RefSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSparseSharedManaged(i), ref field1.RefSparseSharedManaged(i), ref field2.RefSparseSharedManaged(i), ref field3.RefSparseSharedManaged(i), ref field4.RefSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 
     /// <summary>
@@ -203,25 +865,135 @@ public static Entity Find<T0, T1, T2, T3, T4>(Iter it, Ecs.FindPointerCallback<T
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4);
+        IterationTechnique flags = it.GetIterationTechnique(5);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>())
         {
-            if (!callback((T0*)pointer0, (T1*)pointer1, (T2*)pointer2, (T3*)pointer3, (T4*)pointer4))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, Ecs.FindPointerCallback<T0, T1, T2, T3, T4> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerUnmanaged(i), field1.PointerUnmanaged(i), field2.PointerUnmanaged(i), field3.PointerUnmanaged(i), field4.PointerUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, Ecs.FindPointerCallback<T0, T1, T2, T3, T4> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSharedUnmanaged(i), field1.PointerSharedUnmanaged(i), field2.PointerSharedUnmanaged(i), field3.PointerSharedUnmanaged(i), field4.PointerSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, Ecs.FindPointerCallback<T0, T1, T2, T3, T4> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSparseUnmanaged(i), field1.PointerSparseUnmanaged(i), field2.PointerSparseUnmanaged(i), field3.PointerSparseUnmanaged(i), field4.PointerSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, Ecs.FindPointerCallback<T0, T1, T2, T3, T4> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSparseSharedUnmanaged(i), field1.PointerSparseSharedUnmanaged(i), field2.PointerSparseSharedUnmanaged(i), field3.PointerSparseSharedUnmanaged(i), field4.PointerSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, Ecs.FindPointerCallback<T0, T1, T2, T3, T4> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerManaged(i), field1.PointerManaged(i), field2.PointerManaged(i), field3.PointerManaged(i), field4.PointerManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, Ecs.FindPointerCallback<T0, T1, T2, T3, T4> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSharedManaged(i), field1.PointerSharedManaged(i), field2.PointerSharedManaged(i), field3.PointerSharedManaged(i), field4.PointerSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, Ecs.FindPointerCallback<T0, T1, T2, T3, T4> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSparseManaged(i), field1.PointerSparseManaged(i), field2.PointerSparseManaged(i), field3.PointerSparseManaged(i), field4.PointerSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, Ecs.FindPointerCallback<T0, T1, T2, T3, T4> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSparseSharedManaged(i), field1.PointerSparseSharedManaged(i), field2.PointerSparseSharedManaged(i), field3.PointerSparseSharedManaged(i), field4.PointerSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 
     /// <summary>
@@ -234,25 +1006,135 @@ public static Entity Find<T0, T1, T2, T3, T4>(Iter it, Ecs.FindEntityPointerCall
     {
         int count = it.Handle->count; Ecs.Assert(it.Handle->count > 0, "No entities returned, use Iter() or Each() without the entity argument instead.");
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4);
+        IterationTechnique flags = it.GetIterationTechnique(5);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>())
         {
-            if (!callback(new Entity(it.Handle->world, it.Handle->entities[i]), (T0*)pointer0, (T1*)pointer1, (T2*)pointer2, (T3*)pointer3, (T4*)pointer4))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerUnmanaged(i), field1.PointerUnmanaged(i), field2.PointerUnmanaged(i), field3.PointerUnmanaged(i), field4.PointerUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSharedUnmanaged(i), field1.PointerSharedUnmanaged(i), field2.PointerSharedUnmanaged(i), field3.PointerSharedUnmanaged(i), field4.PointerSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseUnmanaged(i), field1.PointerSparseUnmanaged(i), field2.PointerSparseUnmanaged(i), field3.PointerSparseUnmanaged(i), field4.PointerSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseSharedUnmanaged(i), field1.PointerSparseSharedUnmanaged(i), field2.PointerSparseSharedUnmanaged(i), field3.PointerSparseSharedUnmanaged(i), field4.PointerSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerManaged(i), field1.PointerManaged(i), field2.PointerManaged(i), field3.PointerManaged(i), field4.PointerManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSharedManaged(i), field1.PointerSharedManaged(i), field2.PointerSharedManaged(i), field3.PointerSharedManaged(i), field4.PointerSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseManaged(i), field1.PointerSparseManaged(i), field2.PointerSparseManaged(i), field3.PointerSparseManaged(i), field4.PointerSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseSharedManaged(i), field1.PointerSparseSharedManaged(i), field2.PointerSparseSharedManaged(i), field3.PointerSparseSharedManaged(i), field4.PointerSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 
     /// <summary>
@@ -265,25 +1147,135 @@ public static Entity Find<T0, T1, T2, T3, T4>(Iter it, Ecs.FindIterPointerCallba
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4);
+        IterationTechnique flags = it.GetIterationTechnique(5);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>())
         {
-            if (!callback(it, i, (T0*)pointer0, (T1*)pointer1, (T2*)pointer2, (T3*)pointer3, (T4*)pointer4))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerUnmanaged(i), field1.PointerUnmanaged(i), field2.PointerUnmanaged(i), field3.PointerUnmanaged(i), field4.PointerUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSharedUnmanaged(i), field1.PointerSharedUnmanaged(i), field2.PointerSharedUnmanaged(i), field3.PointerSharedUnmanaged(i), field4.PointerSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSparseUnmanaged(i), field1.PointerSparseUnmanaged(i), field2.PointerSparseUnmanaged(i), field3.PointerSparseUnmanaged(i), field4.PointerSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSparseSharedUnmanaged(i), field1.PointerSparseSharedUnmanaged(i), field2.PointerSparseSharedUnmanaged(i), field3.PointerSparseSharedUnmanaged(i), field4.PointerSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerManaged(i), field1.PointerManaged(i), field2.PointerManaged(i), field3.PointerManaged(i), field4.PointerManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSharedManaged(i), field1.PointerSharedManaged(i), field2.PointerSharedManaged(i), field3.PointerSharedManaged(i), field4.PointerSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSparseManaged(i), field1.PointerSparseManaged(i), field2.PointerSparseManaged(i), field3.PointerSparseManaged(i), field4.PointerSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSparseSharedManaged(i), field1.PointerSparseSharedManaged(i), field2.PointerSparseSharedManaged(i), field3.PointerSparseSharedManaged(i), field4.PointerSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 
     /// <summary>
@@ -296,25 +1288,135 @@ public static Entity Find<T0, T1, T2, T3, T4>(Iter it, delegate*<T0*, T1*, T2*,
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4);
+        IterationTechnique flags = it.GetIterationTechnique(5);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>())
         {
-            if (!callback((T0*)pointer0, (T1*)pointer1, (T2*)pointer2, (T3*)pointer3, (T4*)pointer4))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerUnmanaged(i), field1.PointerUnmanaged(i), field2.PointerUnmanaged(i), field3.PointerUnmanaged(i), field4.PointerUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSharedUnmanaged(i), field1.PointerSharedUnmanaged(i), field2.PointerSharedUnmanaged(i), field3.PointerSharedUnmanaged(i), field4.PointerSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSparseUnmanaged(i), field1.PointerSparseUnmanaged(i), field2.PointerSparseUnmanaged(i), field3.PointerSparseUnmanaged(i), field4.PointerSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSparseSharedUnmanaged(i), field1.PointerSparseSharedUnmanaged(i), field2.PointerSparseSharedUnmanaged(i), field3.PointerSparseSharedUnmanaged(i), field4.PointerSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerManaged(i), field1.PointerManaged(i), field2.PointerManaged(i), field3.PointerManaged(i), field4.PointerManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSharedManaged(i), field1.PointerSharedManaged(i), field2.PointerSharedManaged(i), field3.PointerSharedManaged(i), field4.PointerSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSparseManaged(i), field1.PointerSparseManaged(i), field2.PointerSparseManaged(i), field3.PointerSparseManaged(i), field4.PointerSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSparseSharedManaged(i), field1.PointerSparseSharedManaged(i), field2.PointerSparseSharedManaged(i), field3.PointerSparseSharedManaged(i), field4.PointerSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 
     /// <summary>
@@ -327,25 +1429,135 @@ public static Entity Find<T0, T1, T2, T3, T4>(Iter it, delegate*<Entity, T0*, T1
     {
         int count = it.Handle->count; Ecs.Assert(it.Handle->count > 0, "No entities returned, use Iter() or Each() without the entity argument instead.");
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4);
+        IterationTechnique flags = it.GetIterationTechnique(5);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>())
         {
-            if (!callback(new Entity(it.Handle->world, it.Handle->entities[i]), (T0*)pointer0, (T1*)pointer1, (T2*)pointer2, (T3*)pointer3, (T4*)pointer4))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerUnmanaged(i), field1.PointerUnmanaged(i), field2.PointerUnmanaged(i), field3.PointerUnmanaged(i), field4.PointerUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSharedUnmanaged(i), field1.PointerSharedUnmanaged(i), field2.PointerSharedUnmanaged(i), field3.PointerSharedUnmanaged(i), field4.PointerSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseUnmanaged(i), field1.PointerSparseUnmanaged(i), field2.PointerSparseUnmanaged(i), field3.PointerSparseUnmanaged(i), field4.PointerSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseSharedUnmanaged(i), field1.PointerSparseSharedUnmanaged(i), field2.PointerSparseSharedUnmanaged(i), field3.PointerSparseSharedUnmanaged(i), field4.PointerSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerManaged(i), field1.PointerManaged(i), field2.PointerManaged(i), field3.PointerManaged(i), field4.PointerManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSharedManaged(i), field1.PointerSharedManaged(i), field2.PointerSharedManaged(i), field3.PointerSharedManaged(i), field4.PointerSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseManaged(i), field1.PointerSparseManaged(i), field2.PointerSparseManaged(i), field3.PointerSparseManaged(i), field4.PointerSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseSharedManaged(i), field1.PointerSparseSharedManaged(i), field2.PointerSparseSharedManaged(i), field3.PointerSparseSharedManaged(i), field4.PointerSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 
     /// <summary>
@@ -358,24 +1570,134 @@ public static Entity Find<T0, T1, T2, T3, T4>(Iter it, delegate*<Iter, int, T0*,
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4);
+        IterationTechnique flags = it.GetIterationTechnique(5);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>())
         {
-            if (!callback(it, i, (T0*)pointer0, (T1*)pointer1, (T2*)pointer2, (T3*)pointer3, (T4*)pointer4))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerUnmanaged(i), field1.PointerUnmanaged(i), field2.PointerUnmanaged(i), field3.PointerUnmanaged(i), field4.PointerUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSharedUnmanaged(i), field1.PointerSharedUnmanaged(i), field2.PointerSharedUnmanaged(i), field3.PointerSharedUnmanaged(i), field4.PointerSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSparseUnmanaged(i), field1.PointerSparseUnmanaged(i), field2.PointerSparseUnmanaged(i), field3.PointerSparseUnmanaged(i), field4.PointerSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSparseSharedUnmanaged(i), field1.PointerSparseSharedUnmanaged(i), field2.PointerSparseSharedUnmanaged(i), field3.PointerSparseSharedUnmanaged(i), field4.PointerSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerManaged(i), field1.PointerManaged(i), field2.PointerManaged(i), field3.PointerManaged(i), field4.PointerManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSharedManaged(i), field1.PointerSharedManaged(i), field2.PointerSharedManaged(i), field3.PointerSharedManaged(i), field4.PointerSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSparseManaged(i), field1.PointerSparseManaged(i), field2.PointerSparseManaged(i), field3.PointerSparseManaged(i), field4.PointerSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSparseSharedManaged(i), field1.PointerSparseSharedManaged(i), field2.PointerSparseSharedManaged(i), field3.PointerSparseSharedManaged(i), field4.PointerSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 }
\ No newline at end of file
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/Invoker/Find/Iterator/T6.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/Invoker/Find/Iterator/T6.g.cs
index fc956b19..beface4b 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/Invoker/Find/Iterator/T6.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/Invoker/Find/Iterator/T6.g.cs
@@ -1,5 +1,7 @@
 // Find/Iterator/T6.g.cs
 // File was auto-generated by /_/src/Flecs.NET.Codegen/Generators/Invoker.cs
+using System;
+using System.Runtime.CompilerServices;
 using Flecs.NET.Utilities;
 using static Flecs.NET.Bindings.flecs;
 
@@ -17,25 +19,135 @@ public static Entity Find<T0, T1, T2, T3, T4, T5>(Iter it, Ecs.FindRefCallback<T
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5);
+        IterationTechnique flags = it.GetIterationTechnique(6);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>())
         {
-            if (!callback(ref Managed.GetTypeRef<T0>(pointer0), ref Managed.GetTypeRef<T1>(pointer1), ref Managed.GetTypeRef<T2>(pointer2), ref Managed.GetTypeRef<T3>(pointer3), ref Managed.GetTypeRef<T4>(pointer4), ref Managed.GetTypeRef<T5>(pointer5)))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, Ecs.FindRefCallback<T0, T1, T2, T3, T4, T5> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefUnmanaged(i), ref field1.RefUnmanaged(i), ref field2.RefUnmanaged(i), ref field3.RefUnmanaged(i), ref field4.RefUnmanaged(i), ref field5.RefUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, Ecs.FindRefCallback<T0, T1, T2, T3, T4, T5> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSharedUnmanaged(i), ref field1.RefSharedUnmanaged(i), ref field2.RefSharedUnmanaged(i), ref field3.RefSharedUnmanaged(i), ref field4.RefSharedUnmanaged(i), ref field5.RefSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, Ecs.FindRefCallback<T0, T1, T2, T3, T4, T5> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSparseUnmanaged(i), ref field1.RefSparseUnmanaged(i), ref field2.RefSparseUnmanaged(i), ref field3.RefSparseUnmanaged(i), ref field4.RefSparseUnmanaged(i), ref field5.RefSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, Ecs.FindRefCallback<T0, T1, T2, T3, T4, T5> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSparseSharedUnmanaged(i), ref field1.RefSparseSharedUnmanaged(i), ref field2.RefSparseSharedUnmanaged(i), ref field3.RefSparseSharedUnmanaged(i), ref field4.RefSparseSharedUnmanaged(i), ref field5.RefSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, Ecs.FindRefCallback<T0, T1, T2, T3, T4, T5> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefManaged(i), ref field1.RefManaged(i), ref field2.RefManaged(i), ref field3.RefManaged(i), ref field4.RefManaged(i), ref field5.RefManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, Ecs.FindRefCallback<T0, T1, T2, T3, T4, T5> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSharedManaged(i), ref field1.RefSharedManaged(i), ref field2.RefSharedManaged(i), ref field3.RefSharedManaged(i), ref field4.RefSharedManaged(i), ref field5.RefSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, Ecs.FindRefCallback<T0, T1, T2, T3, T4, T5> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSparseManaged(i), ref field1.RefSparseManaged(i), ref field2.RefSparseManaged(i), ref field3.RefSparseManaged(i), ref field4.RefSparseManaged(i), ref field5.RefSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, Ecs.FindRefCallback<T0, T1, T2, T3, T4, T5> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSparseSharedManaged(i), ref field1.RefSparseSharedManaged(i), ref field2.RefSparseSharedManaged(i), ref field3.RefSparseSharedManaged(i), ref field4.RefSparseSharedManaged(i), ref field5.RefSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 
     /// <summary>
@@ -48,25 +160,135 @@ public static Entity Find<T0, T1, T2, T3, T4, T5>(Iter it, Ecs.FindEntityRefCall
     {
         int count = it.Handle->count; Ecs.Assert(it.Handle->count > 0, "No entities returned, use Iter() or Each() without the entity argument instead.");
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5);
+        IterationTechnique flags = it.GetIterationTechnique(6);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>())
         {
-            if (!callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref Managed.GetTypeRef<T0>(pointer0), ref Managed.GetTypeRef<T1>(pointer1), ref Managed.GetTypeRef<T2>(pointer2), ref Managed.GetTypeRef<T3>(pointer3), ref Managed.GetTypeRef<T4>(pointer4), ref Managed.GetTypeRef<T5>(pointer5)))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4, T5> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefUnmanaged(i), ref field1.RefUnmanaged(i), ref field2.RefUnmanaged(i), ref field3.RefUnmanaged(i), ref field4.RefUnmanaged(i), ref field5.RefUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4, T5> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSharedUnmanaged(i), ref field1.RefSharedUnmanaged(i), ref field2.RefSharedUnmanaged(i), ref field3.RefSharedUnmanaged(i), ref field4.RefSharedUnmanaged(i), ref field5.RefSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4, T5> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseUnmanaged(i), ref field1.RefSparseUnmanaged(i), ref field2.RefSparseUnmanaged(i), ref field3.RefSparseUnmanaged(i), ref field4.RefSparseUnmanaged(i), ref field5.RefSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4, T5> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseSharedUnmanaged(i), ref field1.RefSparseSharedUnmanaged(i), ref field2.RefSparseSharedUnmanaged(i), ref field3.RefSparseSharedUnmanaged(i), ref field4.RefSparseSharedUnmanaged(i), ref field5.RefSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4, T5> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefManaged(i), ref field1.RefManaged(i), ref field2.RefManaged(i), ref field3.RefManaged(i), ref field4.RefManaged(i), ref field5.RefManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4, T5> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSharedManaged(i), ref field1.RefSharedManaged(i), ref field2.RefSharedManaged(i), ref field3.RefSharedManaged(i), ref field4.RefSharedManaged(i), ref field5.RefSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4, T5> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseManaged(i), ref field1.RefSparseManaged(i), ref field2.RefSparseManaged(i), ref field3.RefSparseManaged(i), ref field4.RefSparseManaged(i), ref field5.RefSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4, T5> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseSharedManaged(i), ref field1.RefSparseSharedManaged(i), ref field2.RefSparseSharedManaged(i), ref field3.RefSparseSharedManaged(i), ref field4.RefSparseSharedManaged(i), ref field5.RefSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 
     /// <summary>
@@ -79,25 +301,135 @@ public static Entity Find<T0, T1, T2, T3, T4, T5>(Iter it, Ecs.FindIterRefCallba
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5);
+        IterationTechnique flags = it.GetIterationTechnique(6);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>())
         {
-            if (!callback(it, i, ref Managed.GetTypeRef<T0>(pointer0), ref Managed.GetTypeRef<T1>(pointer1), ref Managed.GetTypeRef<T2>(pointer2), ref Managed.GetTypeRef<T3>(pointer3), ref Managed.GetTypeRef<T4>(pointer4), ref Managed.GetTypeRef<T5>(pointer5)))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, Ecs.FindIterRefCallback<T0, T1, T2, T3, T4, T5> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefUnmanaged(i), ref field1.RefUnmanaged(i), ref field2.RefUnmanaged(i), ref field3.RefUnmanaged(i), ref field4.RefUnmanaged(i), ref field5.RefUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, Ecs.FindIterRefCallback<T0, T1, T2, T3, T4, T5> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSharedUnmanaged(i), ref field1.RefSharedUnmanaged(i), ref field2.RefSharedUnmanaged(i), ref field3.RefSharedUnmanaged(i), ref field4.RefSharedUnmanaged(i), ref field5.RefSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, Ecs.FindIterRefCallback<T0, T1, T2, T3, T4, T5> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSparseUnmanaged(i), ref field1.RefSparseUnmanaged(i), ref field2.RefSparseUnmanaged(i), ref field3.RefSparseUnmanaged(i), ref field4.RefSparseUnmanaged(i), ref field5.RefSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, Ecs.FindIterRefCallback<T0, T1, T2, T3, T4, T5> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSparseSharedUnmanaged(i), ref field1.RefSparseSharedUnmanaged(i), ref field2.RefSparseSharedUnmanaged(i), ref field3.RefSparseSharedUnmanaged(i), ref field4.RefSparseSharedUnmanaged(i), ref field5.RefSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, Ecs.FindIterRefCallback<T0, T1, T2, T3, T4, T5> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefManaged(i), ref field1.RefManaged(i), ref field2.RefManaged(i), ref field3.RefManaged(i), ref field4.RefManaged(i), ref field5.RefManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, Ecs.FindIterRefCallback<T0, T1, T2, T3, T4, T5> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSharedManaged(i), ref field1.RefSharedManaged(i), ref field2.RefSharedManaged(i), ref field3.RefSharedManaged(i), ref field4.RefSharedManaged(i), ref field5.RefSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, Ecs.FindIterRefCallback<T0, T1, T2, T3, T4, T5> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSparseManaged(i), ref field1.RefSparseManaged(i), ref field2.RefSparseManaged(i), ref field3.RefSparseManaged(i), ref field4.RefSparseManaged(i), ref field5.RefSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, Ecs.FindIterRefCallback<T0, T1, T2, T3, T4, T5> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSparseSharedManaged(i), ref field1.RefSparseSharedManaged(i), ref field2.RefSparseSharedManaged(i), ref field3.RefSparseSharedManaged(i), ref field4.RefSparseSharedManaged(i), ref field5.RefSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 
     /// <summary>
@@ -110,25 +442,135 @@ public static Entity Find<T0, T1, T2, T3, T4, T5>(Iter it, delegate*<ref T0, ref
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5);
+        IterationTechnique flags = it.GetIterationTechnique(6);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>())
         {
-            if (!callback(ref Managed.GetTypeRef<T0>(pointer0), ref Managed.GetTypeRef<T1>(pointer1), ref Managed.GetTypeRef<T2>(pointer2), ref Managed.GetTypeRef<T3>(pointer3), ref Managed.GetTypeRef<T4>(pointer4), ref Managed.GetTypeRef<T5>(pointer5)))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefUnmanaged(i), ref field1.RefUnmanaged(i), ref field2.RefUnmanaged(i), ref field3.RefUnmanaged(i), ref field4.RefUnmanaged(i), ref field5.RefUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSharedUnmanaged(i), ref field1.RefSharedUnmanaged(i), ref field2.RefSharedUnmanaged(i), ref field3.RefSharedUnmanaged(i), ref field4.RefSharedUnmanaged(i), ref field5.RefSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSparseUnmanaged(i), ref field1.RefSparseUnmanaged(i), ref field2.RefSparseUnmanaged(i), ref field3.RefSparseUnmanaged(i), ref field4.RefSparseUnmanaged(i), ref field5.RefSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSparseSharedUnmanaged(i), ref field1.RefSparseSharedUnmanaged(i), ref field2.RefSparseSharedUnmanaged(i), ref field3.RefSparseSharedUnmanaged(i), ref field4.RefSparseSharedUnmanaged(i), ref field5.RefSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefManaged(i), ref field1.RefManaged(i), ref field2.RefManaged(i), ref field3.RefManaged(i), ref field4.RefManaged(i), ref field5.RefManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSharedManaged(i), ref field1.RefSharedManaged(i), ref field2.RefSharedManaged(i), ref field3.RefSharedManaged(i), ref field4.RefSharedManaged(i), ref field5.RefSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSparseManaged(i), ref field1.RefSparseManaged(i), ref field2.RefSparseManaged(i), ref field3.RefSparseManaged(i), ref field4.RefSparseManaged(i), ref field5.RefSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSparseSharedManaged(i), ref field1.RefSparseSharedManaged(i), ref field2.RefSparseSharedManaged(i), ref field3.RefSparseSharedManaged(i), ref field4.RefSparseSharedManaged(i), ref field5.RefSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 
     /// <summary>
@@ -141,25 +583,135 @@ public static Entity Find<T0, T1, T2, T3, T4, T5>(Iter it, delegate*<Entity, ref
     {
         int count = it.Handle->count; Ecs.Assert(it.Handle->count > 0, "No entities returned, use Iter() or Each() without the entity argument instead.");
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5);
+        IterationTechnique flags = it.GetIterationTechnique(6);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>())
         {
-            if (!callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref Managed.GetTypeRef<T0>(pointer0), ref Managed.GetTypeRef<T1>(pointer1), ref Managed.GetTypeRef<T2>(pointer2), ref Managed.GetTypeRef<T3>(pointer3), ref Managed.GetTypeRef<T4>(pointer4), ref Managed.GetTypeRef<T5>(pointer5)))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefUnmanaged(i), ref field1.RefUnmanaged(i), ref field2.RefUnmanaged(i), ref field3.RefUnmanaged(i), ref field4.RefUnmanaged(i), ref field5.RefUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSharedUnmanaged(i), ref field1.RefSharedUnmanaged(i), ref field2.RefSharedUnmanaged(i), ref field3.RefSharedUnmanaged(i), ref field4.RefSharedUnmanaged(i), ref field5.RefSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseUnmanaged(i), ref field1.RefSparseUnmanaged(i), ref field2.RefSparseUnmanaged(i), ref field3.RefSparseUnmanaged(i), ref field4.RefSparseUnmanaged(i), ref field5.RefSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseSharedUnmanaged(i), ref field1.RefSparseSharedUnmanaged(i), ref field2.RefSparseSharedUnmanaged(i), ref field3.RefSparseSharedUnmanaged(i), ref field4.RefSparseSharedUnmanaged(i), ref field5.RefSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefManaged(i), ref field1.RefManaged(i), ref field2.RefManaged(i), ref field3.RefManaged(i), ref field4.RefManaged(i), ref field5.RefManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSharedManaged(i), ref field1.RefSharedManaged(i), ref field2.RefSharedManaged(i), ref field3.RefSharedManaged(i), ref field4.RefSharedManaged(i), ref field5.RefSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseManaged(i), ref field1.RefSparseManaged(i), ref field2.RefSparseManaged(i), ref field3.RefSparseManaged(i), ref field4.RefSparseManaged(i), ref field5.RefSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseSharedManaged(i), ref field1.RefSparseSharedManaged(i), ref field2.RefSparseSharedManaged(i), ref field3.RefSparseSharedManaged(i), ref field4.RefSparseSharedManaged(i), ref field5.RefSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 
     /// <summary>
@@ -172,25 +724,135 @@ public static Entity Find<T0, T1, T2, T3, T4, T5>(Iter it, delegate*<Iter, int,
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5);
+        IterationTechnique flags = it.GetIterationTechnique(6);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>())
         {
-            if (!callback(it, i, ref Managed.GetTypeRef<T0>(pointer0), ref Managed.GetTypeRef<T1>(pointer1), ref Managed.GetTypeRef<T2>(pointer2), ref Managed.GetTypeRef<T3>(pointer3), ref Managed.GetTypeRef<T4>(pointer4), ref Managed.GetTypeRef<T5>(pointer5)))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefUnmanaged(i), ref field1.RefUnmanaged(i), ref field2.RefUnmanaged(i), ref field3.RefUnmanaged(i), ref field4.RefUnmanaged(i), ref field5.RefUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSharedUnmanaged(i), ref field1.RefSharedUnmanaged(i), ref field2.RefSharedUnmanaged(i), ref field3.RefSharedUnmanaged(i), ref field4.RefSharedUnmanaged(i), ref field5.RefSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSparseUnmanaged(i), ref field1.RefSparseUnmanaged(i), ref field2.RefSparseUnmanaged(i), ref field3.RefSparseUnmanaged(i), ref field4.RefSparseUnmanaged(i), ref field5.RefSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSparseSharedUnmanaged(i), ref field1.RefSparseSharedUnmanaged(i), ref field2.RefSparseSharedUnmanaged(i), ref field3.RefSparseSharedUnmanaged(i), ref field4.RefSparseSharedUnmanaged(i), ref field5.RefSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefManaged(i), ref field1.RefManaged(i), ref field2.RefManaged(i), ref field3.RefManaged(i), ref field4.RefManaged(i), ref field5.RefManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSharedManaged(i), ref field1.RefSharedManaged(i), ref field2.RefSharedManaged(i), ref field3.RefSharedManaged(i), ref field4.RefSharedManaged(i), ref field5.RefSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSparseManaged(i), ref field1.RefSparseManaged(i), ref field2.RefSparseManaged(i), ref field3.RefSparseManaged(i), ref field4.RefSparseManaged(i), ref field5.RefSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSparseSharedManaged(i), ref field1.RefSparseSharedManaged(i), ref field2.RefSparseSharedManaged(i), ref field3.RefSparseSharedManaged(i), ref field4.RefSparseSharedManaged(i), ref field5.RefSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 
     /// <summary>
@@ -203,25 +865,135 @@ public static Entity Find<T0, T1, T2, T3, T4, T5>(Iter it, Ecs.FindPointerCallba
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5);
+        IterationTechnique flags = it.GetIterationTechnique(6);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>())
         {
-            if (!callback((T0*)pointer0, (T1*)pointer1, (T2*)pointer2, (T3*)pointer3, (T4*)pointer4, (T5*)pointer5))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, Ecs.FindPointerCallback<T0, T1, T2, T3, T4, T5> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerUnmanaged(i), field1.PointerUnmanaged(i), field2.PointerUnmanaged(i), field3.PointerUnmanaged(i), field4.PointerUnmanaged(i), field5.PointerUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, Ecs.FindPointerCallback<T0, T1, T2, T3, T4, T5> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSharedUnmanaged(i), field1.PointerSharedUnmanaged(i), field2.PointerSharedUnmanaged(i), field3.PointerSharedUnmanaged(i), field4.PointerSharedUnmanaged(i), field5.PointerSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, Ecs.FindPointerCallback<T0, T1, T2, T3, T4, T5> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSparseUnmanaged(i), field1.PointerSparseUnmanaged(i), field2.PointerSparseUnmanaged(i), field3.PointerSparseUnmanaged(i), field4.PointerSparseUnmanaged(i), field5.PointerSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, Ecs.FindPointerCallback<T0, T1, T2, T3, T4, T5> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSparseSharedUnmanaged(i), field1.PointerSparseSharedUnmanaged(i), field2.PointerSparseSharedUnmanaged(i), field3.PointerSparseSharedUnmanaged(i), field4.PointerSparseSharedUnmanaged(i), field5.PointerSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, Ecs.FindPointerCallback<T0, T1, T2, T3, T4, T5> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerManaged(i), field1.PointerManaged(i), field2.PointerManaged(i), field3.PointerManaged(i), field4.PointerManaged(i), field5.PointerManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, Ecs.FindPointerCallback<T0, T1, T2, T3, T4, T5> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSharedManaged(i), field1.PointerSharedManaged(i), field2.PointerSharedManaged(i), field3.PointerSharedManaged(i), field4.PointerSharedManaged(i), field5.PointerSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, Ecs.FindPointerCallback<T0, T1, T2, T3, T4, T5> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSparseManaged(i), field1.PointerSparseManaged(i), field2.PointerSparseManaged(i), field3.PointerSparseManaged(i), field4.PointerSparseManaged(i), field5.PointerSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, Ecs.FindPointerCallback<T0, T1, T2, T3, T4, T5> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSparseSharedManaged(i), field1.PointerSparseSharedManaged(i), field2.PointerSparseSharedManaged(i), field3.PointerSparseSharedManaged(i), field4.PointerSparseSharedManaged(i), field5.PointerSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 
     /// <summary>
@@ -234,25 +1006,135 @@ public static Entity Find<T0, T1, T2, T3, T4, T5>(Iter it, Ecs.FindEntityPointer
     {
         int count = it.Handle->count; Ecs.Assert(it.Handle->count > 0, "No entities returned, use Iter() or Each() without the entity argument instead.");
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5);
+        IterationTechnique flags = it.GetIterationTechnique(6);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>())
         {
-            if (!callback(new Entity(it.Handle->world, it.Handle->entities[i]), (T0*)pointer0, (T1*)pointer1, (T2*)pointer2, (T3*)pointer3, (T4*)pointer4, (T5*)pointer5))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4, T5> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerUnmanaged(i), field1.PointerUnmanaged(i), field2.PointerUnmanaged(i), field3.PointerUnmanaged(i), field4.PointerUnmanaged(i), field5.PointerUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4, T5> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSharedUnmanaged(i), field1.PointerSharedUnmanaged(i), field2.PointerSharedUnmanaged(i), field3.PointerSharedUnmanaged(i), field4.PointerSharedUnmanaged(i), field5.PointerSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4, T5> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseUnmanaged(i), field1.PointerSparseUnmanaged(i), field2.PointerSparseUnmanaged(i), field3.PointerSparseUnmanaged(i), field4.PointerSparseUnmanaged(i), field5.PointerSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4, T5> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseSharedUnmanaged(i), field1.PointerSparseSharedUnmanaged(i), field2.PointerSparseSharedUnmanaged(i), field3.PointerSparseSharedUnmanaged(i), field4.PointerSparseSharedUnmanaged(i), field5.PointerSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4, T5> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerManaged(i), field1.PointerManaged(i), field2.PointerManaged(i), field3.PointerManaged(i), field4.PointerManaged(i), field5.PointerManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4, T5> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSharedManaged(i), field1.PointerSharedManaged(i), field2.PointerSharedManaged(i), field3.PointerSharedManaged(i), field4.PointerSharedManaged(i), field5.PointerSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4, T5> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseManaged(i), field1.PointerSparseManaged(i), field2.PointerSparseManaged(i), field3.PointerSparseManaged(i), field4.PointerSparseManaged(i), field5.PointerSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4, T5> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseSharedManaged(i), field1.PointerSparseSharedManaged(i), field2.PointerSparseSharedManaged(i), field3.PointerSparseSharedManaged(i), field4.PointerSparseSharedManaged(i), field5.PointerSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 
     /// <summary>
@@ -265,25 +1147,135 @@ public static Entity Find<T0, T1, T2, T3, T4, T5>(Iter it, Ecs.FindIterPointerCa
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5);
+        IterationTechnique flags = it.GetIterationTechnique(6);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>())
         {
-            if (!callback(it, i, (T0*)pointer0, (T1*)pointer1, (T2*)pointer2, (T3*)pointer3, (T4*)pointer4, (T5*)pointer5))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4, T5> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerUnmanaged(i), field1.PointerUnmanaged(i), field2.PointerUnmanaged(i), field3.PointerUnmanaged(i), field4.PointerUnmanaged(i), field5.PointerUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4, T5> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSharedUnmanaged(i), field1.PointerSharedUnmanaged(i), field2.PointerSharedUnmanaged(i), field3.PointerSharedUnmanaged(i), field4.PointerSharedUnmanaged(i), field5.PointerSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4, T5> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSparseUnmanaged(i), field1.PointerSparseUnmanaged(i), field2.PointerSparseUnmanaged(i), field3.PointerSparseUnmanaged(i), field4.PointerSparseUnmanaged(i), field5.PointerSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4, T5> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSparseSharedUnmanaged(i), field1.PointerSparseSharedUnmanaged(i), field2.PointerSparseSharedUnmanaged(i), field3.PointerSparseSharedUnmanaged(i), field4.PointerSparseSharedUnmanaged(i), field5.PointerSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4, T5> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerManaged(i), field1.PointerManaged(i), field2.PointerManaged(i), field3.PointerManaged(i), field4.PointerManaged(i), field5.PointerManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4, T5> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSharedManaged(i), field1.PointerSharedManaged(i), field2.PointerSharedManaged(i), field3.PointerSharedManaged(i), field4.PointerSharedManaged(i), field5.PointerSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4, T5> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSparseManaged(i), field1.PointerSparseManaged(i), field2.PointerSparseManaged(i), field3.PointerSparseManaged(i), field4.PointerSparseManaged(i), field5.PointerSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4, T5> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSparseSharedManaged(i), field1.PointerSparseSharedManaged(i), field2.PointerSparseSharedManaged(i), field3.PointerSparseSharedManaged(i), field4.PointerSparseSharedManaged(i), field5.PointerSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 
     /// <summary>
@@ -296,25 +1288,135 @@ public static Entity Find<T0, T1, T2, T3, T4, T5>(Iter it, delegate*<T0*, T1*, T
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5);
+        IterationTechnique flags = it.GetIterationTechnique(6);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>())
         {
-            if (!callback((T0*)pointer0, (T1*)pointer1, (T2*)pointer2, (T3*)pointer3, (T4*)pointer4, (T5*)pointer5))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, T5*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerUnmanaged(i), field1.PointerUnmanaged(i), field2.PointerUnmanaged(i), field3.PointerUnmanaged(i), field4.PointerUnmanaged(i), field5.PointerUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, T5*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSharedUnmanaged(i), field1.PointerSharedUnmanaged(i), field2.PointerSharedUnmanaged(i), field3.PointerSharedUnmanaged(i), field4.PointerSharedUnmanaged(i), field5.PointerSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, T5*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSparseUnmanaged(i), field1.PointerSparseUnmanaged(i), field2.PointerSparseUnmanaged(i), field3.PointerSparseUnmanaged(i), field4.PointerSparseUnmanaged(i), field5.PointerSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, T5*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSparseSharedUnmanaged(i), field1.PointerSparseSharedUnmanaged(i), field2.PointerSparseSharedUnmanaged(i), field3.PointerSparseSharedUnmanaged(i), field4.PointerSparseSharedUnmanaged(i), field5.PointerSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, T5*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerManaged(i), field1.PointerManaged(i), field2.PointerManaged(i), field3.PointerManaged(i), field4.PointerManaged(i), field5.PointerManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, T5*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSharedManaged(i), field1.PointerSharedManaged(i), field2.PointerSharedManaged(i), field3.PointerSharedManaged(i), field4.PointerSharedManaged(i), field5.PointerSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, T5*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSparseManaged(i), field1.PointerSparseManaged(i), field2.PointerSparseManaged(i), field3.PointerSparseManaged(i), field4.PointerSparseManaged(i), field5.PointerSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, T5*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSparseSharedManaged(i), field1.PointerSparseSharedManaged(i), field2.PointerSparseSharedManaged(i), field3.PointerSparseSharedManaged(i), field4.PointerSparseSharedManaged(i), field5.PointerSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 
     /// <summary>
@@ -327,25 +1429,135 @@ public static Entity Find<T0, T1, T2, T3, T4, T5>(Iter it, delegate*<Entity, T0*
     {
         int count = it.Handle->count; Ecs.Assert(it.Handle->count > 0, "No entities returned, use Iter() or Each() without the entity argument instead.");
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5);
+        IterationTechnique flags = it.GetIterationTechnique(6);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>())
         {
-            if (!callback(new Entity(it.Handle->world, it.Handle->entities[i]), (T0*)pointer0, (T1*)pointer1, (T2*)pointer2, (T3*)pointer3, (T4*)pointer4, (T5*)pointer5))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerUnmanaged(i), field1.PointerUnmanaged(i), field2.PointerUnmanaged(i), field3.PointerUnmanaged(i), field4.PointerUnmanaged(i), field5.PointerUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSharedUnmanaged(i), field1.PointerSharedUnmanaged(i), field2.PointerSharedUnmanaged(i), field3.PointerSharedUnmanaged(i), field4.PointerSharedUnmanaged(i), field5.PointerSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseUnmanaged(i), field1.PointerSparseUnmanaged(i), field2.PointerSparseUnmanaged(i), field3.PointerSparseUnmanaged(i), field4.PointerSparseUnmanaged(i), field5.PointerSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseSharedUnmanaged(i), field1.PointerSparseSharedUnmanaged(i), field2.PointerSparseSharedUnmanaged(i), field3.PointerSparseSharedUnmanaged(i), field4.PointerSparseSharedUnmanaged(i), field5.PointerSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerManaged(i), field1.PointerManaged(i), field2.PointerManaged(i), field3.PointerManaged(i), field4.PointerManaged(i), field5.PointerManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSharedManaged(i), field1.PointerSharedManaged(i), field2.PointerSharedManaged(i), field3.PointerSharedManaged(i), field4.PointerSharedManaged(i), field5.PointerSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseManaged(i), field1.PointerSparseManaged(i), field2.PointerSparseManaged(i), field3.PointerSparseManaged(i), field4.PointerSparseManaged(i), field5.PointerSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseSharedManaged(i), field1.PointerSparseSharedManaged(i), field2.PointerSparseSharedManaged(i), field3.PointerSparseSharedManaged(i), field4.PointerSparseSharedManaged(i), field5.PointerSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 
     /// <summary>
@@ -358,24 +1570,134 @@ public static Entity Find<T0, T1, T2, T3, T4, T5>(Iter it, delegate*<Iter, int,
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5);
+        IterationTechnique flags = it.GetIterationTechnique(6);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>())
         {
-            if (!callback(it, i, (T0*)pointer0, (T1*)pointer1, (T2*)pointer2, (T3*)pointer3, (T4*)pointer4, (T5*)pointer5))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerUnmanaged(i), field1.PointerUnmanaged(i), field2.PointerUnmanaged(i), field3.PointerUnmanaged(i), field4.PointerUnmanaged(i), field5.PointerUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSharedUnmanaged(i), field1.PointerSharedUnmanaged(i), field2.PointerSharedUnmanaged(i), field3.PointerSharedUnmanaged(i), field4.PointerSharedUnmanaged(i), field5.PointerSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSparseUnmanaged(i), field1.PointerSparseUnmanaged(i), field2.PointerSparseUnmanaged(i), field3.PointerSparseUnmanaged(i), field4.PointerSparseUnmanaged(i), field5.PointerSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSparseSharedUnmanaged(i), field1.PointerSparseSharedUnmanaged(i), field2.PointerSparseSharedUnmanaged(i), field3.PointerSparseSharedUnmanaged(i), field4.PointerSparseSharedUnmanaged(i), field5.PointerSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerManaged(i), field1.PointerManaged(i), field2.PointerManaged(i), field3.PointerManaged(i), field4.PointerManaged(i), field5.PointerManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSharedManaged(i), field1.PointerSharedManaged(i), field2.PointerSharedManaged(i), field3.PointerSharedManaged(i), field4.PointerSharedManaged(i), field5.PointerSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSparseManaged(i), field1.PointerSparseManaged(i), field2.PointerSparseManaged(i), field3.PointerSparseManaged(i), field4.PointerSparseManaged(i), field5.PointerSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSparseSharedManaged(i), field1.PointerSparseSharedManaged(i), field2.PointerSparseSharedManaged(i), field3.PointerSparseSharedManaged(i), field4.PointerSparseSharedManaged(i), field5.PointerSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 }
\ No newline at end of file
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/Invoker/Find/Iterator/T7.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/Invoker/Find/Iterator/T7.g.cs
index 8d6482df..6877284a 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/Invoker/Find/Iterator/T7.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/Invoker/Find/Iterator/T7.g.cs
@@ -1,5 +1,7 @@
 // Find/Iterator/T7.g.cs
 // File was auto-generated by /_/src/Flecs.NET.Codegen/Generators/Invoker.cs
+using System;
+using System.Runtime.CompilerServices;
 using Flecs.NET.Utilities;
 using static Flecs.NET.Bindings.flecs;
 
@@ -17,25 +19,135 @@ public static Entity Find<T0, T1, T2, T3, T4, T5, T6>(Iter it, Ecs.FindRefCallba
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6);
+        IterationTechnique flags = it.GetIterationTechnique(7);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>())
         {
-            if (!callback(ref Managed.GetTypeRef<T0>(pointer0), ref Managed.GetTypeRef<T1>(pointer1), ref Managed.GetTypeRef<T2>(pointer2), ref Managed.GetTypeRef<T3>(pointer3), ref Managed.GetTypeRef<T4>(pointer4), ref Managed.GetTypeRef<T5>(pointer5), ref Managed.GetTypeRef<T6>(pointer6)))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, Ecs.FindRefCallback<T0, T1, T2, T3, T4, T5, T6> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefUnmanaged(i), ref field1.RefUnmanaged(i), ref field2.RefUnmanaged(i), ref field3.RefUnmanaged(i), ref field4.RefUnmanaged(i), ref field5.RefUnmanaged(i), ref field6.RefUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, Ecs.FindRefCallback<T0, T1, T2, T3, T4, T5, T6> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSharedUnmanaged(i), ref field1.RefSharedUnmanaged(i), ref field2.RefSharedUnmanaged(i), ref field3.RefSharedUnmanaged(i), ref field4.RefSharedUnmanaged(i), ref field5.RefSharedUnmanaged(i), ref field6.RefSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, Ecs.FindRefCallback<T0, T1, T2, T3, T4, T5, T6> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSparseUnmanaged(i), ref field1.RefSparseUnmanaged(i), ref field2.RefSparseUnmanaged(i), ref field3.RefSparseUnmanaged(i), ref field4.RefSparseUnmanaged(i), ref field5.RefSparseUnmanaged(i), ref field6.RefSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, Ecs.FindRefCallback<T0, T1, T2, T3, T4, T5, T6> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSparseSharedUnmanaged(i), ref field1.RefSparseSharedUnmanaged(i), ref field2.RefSparseSharedUnmanaged(i), ref field3.RefSparseSharedUnmanaged(i), ref field4.RefSparseSharedUnmanaged(i), ref field5.RefSparseSharedUnmanaged(i), ref field6.RefSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, Ecs.FindRefCallback<T0, T1, T2, T3, T4, T5, T6> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefManaged(i), ref field1.RefManaged(i), ref field2.RefManaged(i), ref field3.RefManaged(i), ref field4.RefManaged(i), ref field5.RefManaged(i), ref field6.RefManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, Ecs.FindRefCallback<T0, T1, T2, T3, T4, T5, T6> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSharedManaged(i), ref field1.RefSharedManaged(i), ref field2.RefSharedManaged(i), ref field3.RefSharedManaged(i), ref field4.RefSharedManaged(i), ref field5.RefSharedManaged(i), ref field6.RefSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, Ecs.FindRefCallback<T0, T1, T2, T3, T4, T5, T6> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSparseManaged(i), ref field1.RefSparseManaged(i), ref field2.RefSparseManaged(i), ref field3.RefSparseManaged(i), ref field4.RefSparseManaged(i), ref field5.RefSparseManaged(i), ref field6.RefSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, Ecs.FindRefCallback<T0, T1, T2, T3, T4, T5, T6> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSparseSharedManaged(i), ref field1.RefSparseSharedManaged(i), ref field2.RefSparseSharedManaged(i), ref field3.RefSparseSharedManaged(i), ref field4.RefSparseSharedManaged(i), ref field5.RefSparseSharedManaged(i), ref field6.RefSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 
     /// <summary>
@@ -48,25 +160,135 @@ public static Entity Find<T0, T1, T2, T3, T4, T5, T6>(Iter it, Ecs.FindEntityRef
     {
         int count = it.Handle->count; Ecs.Assert(it.Handle->count > 0, "No entities returned, use Iter() or Each() without the entity argument instead.");
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6);
+        IterationTechnique flags = it.GetIterationTechnique(7);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>())
         {
-            if (!callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref Managed.GetTypeRef<T0>(pointer0), ref Managed.GetTypeRef<T1>(pointer1), ref Managed.GetTypeRef<T2>(pointer2), ref Managed.GetTypeRef<T3>(pointer3), ref Managed.GetTypeRef<T4>(pointer4), ref Managed.GetTypeRef<T5>(pointer5), ref Managed.GetTypeRef<T6>(pointer6)))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4, T5, T6> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefUnmanaged(i), ref field1.RefUnmanaged(i), ref field2.RefUnmanaged(i), ref field3.RefUnmanaged(i), ref field4.RefUnmanaged(i), ref field5.RefUnmanaged(i), ref field6.RefUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4, T5, T6> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSharedUnmanaged(i), ref field1.RefSharedUnmanaged(i), ref field2.RefSharedUnmanaged(i), ref field3.RefSharedUnmanaged(i), ref field4.RefSharedUnmanaged(i), ref field5.RefSharedUnmanaged(i), ref field6.RefSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4, T5, T6> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseUnmanaged(i), ref field1.RefSparseUnmanaged(i), ref field2.RefSparseUnmanaged(i), ref field3.RefSparseUnmanaged(i), ref field4.RefSparseUnmanaged(i), ref field5.RefSparseUnmanaged(i), ref field6.RefSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4, T5, T6> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseSharedUnmanaged(i), ref field1.RefSparseSharedUnmanaged(i), ref field2.RefSparseSharedUnmanaged(i), ref field3.RefSparseSharedUnmanaged(i), ref field4.RefSparseSharedUnmanaged(i), ref field5.RefSparseSharedUnmanaged(i), ref field6.RefSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4, T5, T6> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefManaged(i), ref field1.RefManaged(i), ref field2.RefManaged(i), ref field3.RefManaged(i), ref field4.RefManaged(i), ref field5.RefManaged(i), ref field6.RefManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4, T5, T6> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSharedManaged(i), ref field1.RefSharedManaged(i), ref field2.RefSharedManaged(i), ref field3.RefSharedManaged(i), ref field4.RefSharedManaged(i), ref field5.RefSharedManaged(i), ref field6.RefSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4, T5, T6> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseManaged(i), ref field1.RefSparseManaged(i), ref field2.RefSparseManaged(i), ref field3.RefSparseManaged(i), ref field4.RefSparseManaged(i), ref field5.RefSparseManaged(i), ref field6.RefSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4, T5, T6> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseSharedManaged(i), ref field1.RefSparseSharedManaged(i), ref field2.RefSparseSharedManaged(i), ref field3.RefSparseSharedManaged(i), ref field4.RefSparseSharedManaged(i), ref field5.RefSparseSharedManaged(i), ref field6.RefSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 
     /// <summary>
@@ -79,25 +301,135 @@ public static Entity Find<T0, T1, T2, T3, T4, T5, T6>(Iter it, Ecs.FindIterRefCa
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6);
+        IterationTechnique flags = it.GetIterationTechnique(7);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>())
         {
-            if (!callback(it, i, ref Managed.GetTypeRef<T0>(pointer0), ref Managed.GetTypeRef<T1>(pointer1), ref Managed.GetTypeRef<T2>(pointer2), ref Managed.GetTypeRef<T3>(pointer3), ref Managed.GetTypeRef<T4>(pointer4), ref Managed.GetTypeRef<T5>(pointer5), ref Managed.GetTypeRef<T6>(pointer6)))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, Ecs.FindIterRefCallback<T0, T1, T2, T3, T4, T5, T6> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefUnmanaged(i), ref field1.RefUnmanaged(i), ref field2.RefUnmanaged(i), ref field3.RefUnmanaged(i), ref field4.RefUnmanaged(i), ref field5.RefUnmanaged(i), ref field6.RefUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, Ecs.FindIterRefCallback<T0, T1, T2, T3, T4, T5, T6> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSharedUnmanaged(i), ref field1.RefSharedUnmanaged(i), ref field2.RefSharedUnmanaged(i), ref field3.RefSharedUnmanaged(i), ref field4.RefSharedUnmanaged(i), ref field5.RefSharedUnmanaged(i), ref field6.RefSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, Ecs.FindIterRefCallback<T0, T1, T2, T3, T4, T5, T6> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSparseUnmanaged(i), ref field1.RefSparseUnmanaged(i), ref field2.RefSparseUnmanaged(i), ref field3.RefSparseUnmanaged(i), ref field4.RefSparseUnmanaged(i), ref field5.RefSparseUnmanaged(i), ref field6.RefSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, Ecs.FindIterRefCallback<T0, T1, T2, T3, T4, T5, T6> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSparseSharedUnmanaged(i), ref field1.RefSparseSharedUnmanaged(i), ref field2.RefSparseSharedUnmanaged(i), ref field3.RefSparseSharedUnmanaged(i), ref field4.RefSparseSharedUnmanaged(i), ref field5.RefSparseSharedUnmanaged(i), ref field6.RefSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, Ecs.FindIterRefCallback<T0, T1, T2, T3, T4, T5, T6> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefManaged(i), ref field1.RefManaged(i), ref field2.RefManaged(i), ref field3.RefManaged(i), ref field4.RefManaged(i), ref field5.RefManaged(i), ref field6.RefManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, Ecs.FindIterRefCallback<T0, T1, T2, T3, T4, T5, T6> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSharedManaged(i), ref field1.RefSharedManaged(i), ref field2.RefSharedManaged(i), ref field3.RefSharedManaged(i), ref field4.RefSharedManaged(i), ref field5.RefSharedManaged(i), ref field6.RefSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, Ecs.FindIterRefCallback<T0, T1, T2, T3, T4, T5, T6> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSparseManaged(i), ref field1.RefSparseManaged(i), ref field2.RefSparseManaged(i), ref field3.RefSparseManaged(i), ref field4.RefSparseManaged(i), ref field5.RefSparseManaged(i), ref field6.RefSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, Ecs.FindIterRefCallback<T0, T1, T2, T3, T4, T5, T6> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSparseSharedManaged(i), ref field1.RefSparseSharedManaged(i), ref field2.RefSparseSharedManaged(i), ref field3.RefSparseSharedManaged(i), ref field4.RefSparseSharedManaged(i), ref field5.RefSparseSharedManaged(i), ref field6.RefSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 
     /// <summary>
@@ -110,25 +442,135 @@ public static Entity Find<T0, T1, T2, T3, T4, T5, T6>(Iter it, delegate*<ref T0,
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6);
+        IterationTechnique flags = it.GetIterationTechnique(7);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>())
         {
-            if (!callback(ref Managed.GetTypeRef<T0>(pointer0), ref Managed.GetTypeRef<T1>(pointer1), ref Managed.GetTypeRef<T2>(pointer2), ref Managed.GetTypeRef<T3>(pointer3), ref Managed.GetTypeRef<T4>(pointer4), ref Managed.GetTypeRef<T5>(pointer5), ref Managed.GetTypeRef<T6>(pointer6)))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefUnmanaged(i), ref field1.RefUnmanaged(i), ref field2.RefUnmanaged(i), ref field3.RefUnmanaged(i), ref field4.RefUnmanaged(i), ref field5.RefUnmanaged(i), ref field6.RefUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSharedUnmanaged(i), ref field1.RefSharedUnmanaged(i), ref field2.RefSharedUnmanaged(i), ref field3.RefSharedUnmanaged(i), ref field4.RefSharedUnmanaged(i), ref field5.RefSharedUnmanaged(i), ref field6.RefSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSparseUnmanaged(i), ref field1.RefSparseUnmanaged(i), ref field2.RefSparseUnmanaged(i), ref field3.RefSparseUnmanaged(i), ref field4.RefSparseUnmanaged(i), ref field5.RefSparseUnmanaged(i), ref field6.RefSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSparseSharedUnmanaged(i), ref field1.RefSparseSharedUnmanaged(i), ref field2.RefSparseSharedUnmanaged(i), ref field3.RefSparseSharedUnmanaged(i), ref field4.RefSparseSharedUnmanaged(i), ref field5.RefSparseSharedUnmanaged(i), ref field6.RefSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefManaged(i), ref field1.RefManaged(i), ref field2.RefManaged(i), ref field3.RefManaged(i), ref field4.RefManaged(i), ref field5.RefManaged(i), ref field6.RefManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSharedManaged(i), ref field1.RefSharedManaged(i), ref field2.RefSharedManaged(i), ref field3.RefSharedManaged(i), ref field4.RefSharedManaged(i), ref field5.RefSharedManaged(i), ref field6.RefSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSparseManaged(i), ref field1.RefSparseManaged(i), ref field2.RefSparseManaged(i), ref field3.RefSparseManaged(i), ref field4.RefSparseManaged(i), ref field5.RefSparseManaged(i), ref field6.RefSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSparseSharedManaged(i), ref field1.RefSparseSharedManaged(i), ref field2.RefSparseSharedManaged(i), ref field3.RefSparseSharedManaged(i), ref field4.RefSparseSharedManaged(i), ref field5.RefSparseSharedManaged(i), ref field6.RefSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 
     /// <summary>
@@ -141,25 +583,135 @@ public static Entity Find<T0, T1, T2, T3, T4, T5, T6>(Iter it, delegate*<Entity,
     {
         int count = it.Handle->count; Ecs.Assert(it.Handle->count > 0, "No entities returned, use Iter() or Each() without the entity argument instead.");
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6);
+        IterationTechnique flags = it.GetIterationTechnique(7);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>())
         {
-            if (!callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref Managed.GetTypeRef<T0>(pointer0), ref Managed.GetTypeRef<T1>(pointer1), ref Managed.GetTypeRef<T2>(pointer2), ref Managed.GetTypeRef<T3>(pointer3), ref Managed.GetTypeRef<T4>(pointer4), ref Managed.GetTypeRef<T5>(pointer5), ref Managed.GetTypeRef<T6>(pointer6)))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefUnmanaged(i), ref field1.RefUnmanaged(i), ref field2.RefUnmanaged(i), ref field3.RefUnmanaged(i), ref field4.RefUnmanaged(i), ref field5.RefUnmanaged(i), ref field6.RefUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSharedUnmanaged(i), ref field1.RefSharedUnmanaged(i), ref field2.RefSharedUnmanaged(i), ref field3.RefSharedUnmanaged(i), ref field4.RefSharedUnmanaged(i), ref field5.RefSharedUnmanaged(i), ref field6.RefSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseUnmanaged(i), ref field1.RefSparseUnmanaged(i), ref field2.RefSparseUnmanaged(i), ref field3.RefSparseUnmanaged(i), ref field4.RefSparseUnmanaged(i), ref field5.RefSparseUnmanaged(i), ref field6.RefSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseSharedUnmanaged(i), ref field1.RefSparseSharedUnmanaged(i), ref field2.RefSparseSharedUnmanaged(i), ref field3.RefSparseSharedUnmanaged(i), ref field4.RefSparseSharedUnmanaged(i), ref field5.RefSparseSharedUnmanaged(i), ref field6.RefSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefManaged(i), ref field1.RefManaged(i), ref field2.RefManaged(i), ref field3.RefManaged(i), ref field4.RefManaged(i), ref field5.RefManaged(i), ref field6.RefManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSharedManaged(i), ref field1.RefSharedManaged(i), ref field2.RefSharedManaged(i), ref field3.RefSharedManaged(i), ref field4.RefSharedManaged(i), ref field5.RefSharedManaged(i), ref field6.RefSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseManaged(i), ref field1.RefSparseManaged(i), ref field2.RefSparseManaged(i), ref field3.RefSparseManaged(i), ref field4.RefSparseManaged(i), ref field5.RefSparseManaged(i), ref field6.RefSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseSharedManaged(i), ref field1.RefSparseSharedManaged(i), ref field2.RefSparseSharedManaged(i), ref field3.RefSparseSharedManaged(i), ref field4.RefSparseSharedManaged(i), ref field5.RefSparseSharedManaged(i), ref field6.RefSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 
     /// <summary>
@@ -172,25 +724,135 @@ public static Entity Find<T0, T1, T2, T3, T4, T5, T6>(Iter it, delegate*<Iter, i
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6);
+        IterationTechnique flags = it.GetIterationTechnique(7);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>())
         {
-            if (!callback(it, i, ref Managed.GetTypeRef<T0>(pointer0), ref Managed.GetTypeRef<T1>(pointer1), ref Managed.GetTypeRef<T2>(pointer2), ref Managed.GetTypeRef<T3>(pointer3), ref Managed.GetTypeRef<T4>(pointer4), ref Managed.GetTypeRef<T5>(pointer5), ref Managed.GetTypeRef<T6>(pointer6)))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefUnmanaged(i), ref field1.RefUnmanaged(i), ref field2.RefUnmanaged(i), ref field3.RefUnmanaged(i), ref field4.RefUnmanaged(i), ref field5.RefUnmanaged(i), ref field6.RefUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSharedUnmanaged(i), ref field1.RefSharedUnmanaged(i), ref field2.RefSharedUnmanaged(i), ref field3.RefSharedUnmanaged(i), ref field4.RefSharedUnmanaged(i), ref field5.RefSharedUnmanaged(i), ref field6.RefSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSparseUnmanaged(i), ref field1.RefSparseUnmanaged(i), ref field2.RefSparseUnmanaged(i), ref field3.RefSparseUnmanaged(i), ref field4.RefSparseUnmanaged(i), ref field5.RefSparseUnmanaged(i), ref field6.RefSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSparseSharedUnmanaged(i), ref field1.RefSparseSharedUnmanaged(i), ref field2.RefSparseSharedUnmanaged(i), ref field3.RefSparseSharedUnmanaged(i), ref field4.RefSparseSharedUnmanaged(i), ref field5.RefSparseSharedUnmanaged(i), ref field6.RefSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefManaged(i), ref field1.RefManaged(i), ref field2.RefManaged(i), ref field3.RefManaged(i), ref field4.RefManaged(i), ref field5.RefManaged(i), ref field6.RefManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSharedManaged(i), ref field1.RefSharedManaged(i), ref field2.RefSharedManaged(i), ref field3.RefSharedManaged(i), ref field4.RefSharedManaged(i), ref field5.RefSharedManaged(i), ref field6.RefSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSparseManaged(i), ref field1.RefSparseManaged(i), ref field2.RefSparseManaged(i), ref field3.RefSparseManaged(i), ref field4.RefSparseManaged(i), ref field5.RefSparseManaged(i), ref field6.RefSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSparseSharedManaged(i), ref field1.RefSparseSharedManaged(i), ref field2.RefSparseSharedManaged(i), ref field3.RefSparseSharedManaged(i), ref field4.RefSparseSharedManaged(i), ref field5.RefSparseSharedManaged(i), ref field6.RefSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 
     /// <summary>
@@ -203,25 +865,135 @@ public static Entity Find<T0, T1, T2, T3, T4, T5, T6>(Iter it, Ecs.FindPointerCa
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6);
+        IterationTechnique flags = it.GetIterationTechnique(7);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>())
         {
-            if (!callback((T0*)pointer0, (T1*)pointer1, (T2*)pointer2, (T3*)pointer3, (T4*)pointer4, (T5*)pointer5, (T6*)pointer6))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, Ecs.FindPointerCallback<T0, T1, T2, T3, T4, T5, T6> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerUnmanaged(i), field1.PointerUnmanaged(i), field2.PointerUnmanaged(i), field3.PointerUnmanaged(i), field4.PointerUnmanaged(i), field5.PointerUnmanaged(i), field6.PointerUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, Ecs.FindPointerCallback<T0, T1, T2, T3, T4, T5, T6> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSharedUnmanaged(i), field1.PointerSharedUnmanaged(i), field2.PointerSharedUnmanaged(i), field3.PointerSharedUnmanaged(i), field4.PointerSharedUnmanaged(i), field5.PointerSharedUnmanaged(i), field6.PointerSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, Ecs.FindPointerCallback<T0, T1, T2, T3, T4, T5, T6> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSparseUnmanaged(i), field1.PointerSparseUnmanaged(i), field2.PointerSparseUnmanaged(i), field3.PointerSparseUnmanaged(i), field4.PointerSparseUnmanaged(i), field5.PointerSparseUnmanaged(i), field6.PointerSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, Ecs.FindPointerCallback<T0, T1, T2, T3, T4, T5, T6> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSparseSharedUnmanaged(i), field1.PointerSparseSharedUnmanaged(i), field2.PointerSparseSharedUnmanaged(i), field3.PointerSparseSharedUnmanaged(i), field4.PointerSparseSharedUnmanaged(i), field5.PointerSparseSharedUnmanaged(i), field6.PointerSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, Ecs.FindPointerCallback<T0, T1, T2, T3, T4, T5, T6> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerManaged(i), field1.PointerManaged(i), field2.PointerManaged(i), field3.PointerManaged(i), field4.PointerManaged(i), field5.PointerManaged(i), field6.PointerManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, Ecs.FindPointerCallback<T0, T1, T2, T3, T4, T5, T6> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSharedManaged(i), field1.PointerSharedManaged(i), field2.PointerSharedManaged(i), field3.PointerSharedManaged(i), field4.PointerSharedManaged(i), field5.PointerSharedManaged(i), field6.PointerSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, Ecs.FindPointerCallback<T0, T1, T2, T3, T4, T5, T6> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSparseManaged(i), field1.PointerSparseManaged(i), field2.PointerSparseManaged(i), field3.PointerSparseManaged(i), field4.PointerSparseManaged(i), field5.PointerSparseManaged(i), field6.PointerSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, Ecs.FindPointerCallback<T0, T1, T2, T3, T4, T5, T6> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSparseSharedManaged(i), field1.PointerSparseSharedManaged(i), field2.PointerSparseSharedManaged(i), field3.PointerSparseSharedManaged(i), field4.PointerSparseSharedManaged(i), field5.PointerSparseSharedManaged(i), field6.PointerSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 
     /// <summary>
@@ -234,25 +1006,135 @@ public static Entity Find<T0, T1, T2, T3, T4, T5, T6>(Iter it, Ecs.FindEntityPoi
     {
         int count = it.Handle->count; Ecs.Assert(it.Handle->count > 0, "No entities returned, use Iter() or Each() without the entity argument instead.");
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6);
+        IterationTechnique flags = it.GetIterationTechnique(7);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>())
         {
-            if (!callback(new Entity(it.Handle->world, it.Handle->entities[i]), (T0*)pointer0, (T1*)pointer1, (T2*)pointer2, (T3*)pointer3, (T4*)pointer4, (T5*)pointer5, (T6*)pointer6))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerUnmanaged(i), field1.PointerUnmanaged(i), field2.PointerUnmanaged(i), field3.PointerUnmanaged(i), field4.PointerUnmanaged(i), field5.PointerUnmanaged(i), field6.PointerUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSharedUnmanaged(i), field1.PointerSharedUnmanaged(i), field2.PointerSharedUnmanaged(i), field3.PointerSharedUnmanaged(i), field4.PointerSharedUnmanaged(i), field5.PointerSharedUnmanaged(i), field6.PointerSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseUnmanaged(i), field1.PointerSparseUnmanaged(i), field2.PointerSparseUnmanaged(i), field3.PointerSparseUnmanaged(i), field4.PointerSparseUnmanaged(i), field5.PointerSparseUnmanaged(i), field6.PointerSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseSharedUnmanaged(i), field1.PointerSparseSharedUnmanaged(i), field2.PointerSparseSharedUnmanaged(i), field3.PointerSparseSharedUnmanaged(i), field4.PointerSparseSharedUnmanaged(i), field5.PointerSparseSharedUnmanaged(i), field6.PointerSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerManaged(i), field1.PointerManaged(i), field2.PointerManaged(i), field3.PointerManaged(i), field4.PointerManaged(i), field5.PointerManaged(i), field6.PointerManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSharedManaged(i), field1.PointerSharedManaged(i), field2.PointerSharedManaged(i), field3.PointerSharedManaged(i), field4.PointerSharedManaged(i), field5.PointerSharedManaged(i), field6.PointerSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseManaged(i), field1.PointerSparseManaged(i), field2.PointerSparseManaged(i), field3.PointerSparseManaged(i), field4.PointerSparseManaged(i), field5.PointerSparseManaged(i), field6.PointerSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseSharedManaged(i), field1.PointerSparseSharedManaged(i), field2.PointerSparseSharedManaged(i), field3.PointerSparseSharedManaged(i), field4.PointerSparseSharedManaged(i), field5.PointerSparseSharedManaged(i), field6.PointerSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 
     /// <summary>
@@ -265,25 +1147,135 @@ public static Entity Find<T0, T1, T2, T3, T4, T5, T6>(Iter it, Ecs.FindIterPoint
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6);
+        IterationTechnique flags = it.GetIterationTechnique(7);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>())
         {
-            if (!callback(it, i, (T0*)pointer0, (T1*)pointer1, (T2*)pointer2, (T3*)pointer3, (T4*)pointer4, (T5*)pointer5, (T6*)pointer6))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4, T5, T6> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerUnmanaged(i), field1.PointerUnmanaged(i), field2.PointerUnmanaged(i), field3.PointerUnmanaged(i), field4.PointerUnmanaged(i), field5.PointerUnmanaged(i), field6.PointerUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4, T5, T6> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSharedUnmanaged(i), field1.PointerSharedUnmanaged(i), field2.PointerSharedUnmanaged(i), field3.PointerSharedUnmanaged(i), field4.PointerSharedUnmanaged(i), field5.PointerSharedUnmanaged(i), field6.PointerSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4, T5, T6> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSparseUnmanaged(i), field1.PointerSparseUnmanaged(i), field2.PointerSparseUnmanaged(i), field3.PointerSparseUnmanaged(i), field4.PointerSparseUnmanaged(i), field5.PointerSparseUnmanaged(i), field6.PointerSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4, T5, T6> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSparseSharedUnmanaged(i), field1.PointerSparseSharedUnmanaged(i), field2.PointerSparseSharedUnmanaged(i), field3.PointerSparseSharedUnmanaged(i), field4.PointerSparseSharedUnmanaged(i), field5.PointerSparseSharedUnmanaged(i), field6.PointerSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4, T5, T6> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerManaged(i), field1.PointerManaged(i), field2.PointerManaged(i), field3.PointerManaged(i), field4.PointerManaged(i), field5.PointerManaged(i), field6.PointerManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4, T5, T6> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSharedManaged(i), field1.PointerSharedManaged(i), field2.PointerSharedManaged(i), field3.PointerSharedManaged(i), field4.PointerSharedManaged(i), field5.PointerSharedManaged(i), field6.PointerSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4, T5, T6> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSparseManaged(i), field1.PointerSparseManaged(i), field2.PointerSparseManaged(i), field3.PointerSparseManaged(i), field4.PointerSparseManaged(i), field5.PointerSparseManaged(i), field6.PointerSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4, T5, T6> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSparseSharedManaged(i), field1.PointerSparseSharedManaged(i), field2.PointerSparseSharedManaged(i), field3.PointerSparseSharedManaged(i), field4.PointerSparseSharedManaged(i), field5.PointerSparseSharedManaged(i), field6.PointerSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 
     /// <summary>
@@ -296,25 +1288,135 @@ public static Entity Find<T0, T1, T2, T3, T4, T5, T6>(Iter it, delegate*<T0*, T1
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6);
+        IterationTechnique flags = it.GetIterationTechnique(7);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>())
         {
-            if (!callback((T0*)pointer0, (T1*)pointer1, (T2*)pointer2, (T3*)pointer3, (T4*)pointer4, (T5*)pointer5, (T6*)pointer6))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerUnmanaged(i), field1.PointerUnmanaged(i), field2.PointerUnmanaged(i), field3.PointerUnmanaged(i), field4.PointerUnmanaged(i), field5.PointerUnmanaged(i), field6.PointerUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSharedUnmanaged(i), field1.PointerSharedUnmanaged(i), field2.PointerSharedUnmanaged(i), field3.PointerSharedUnmanaged(i), field4.PointerSharedUnmanaged(i), field5.PointerSharedUnmanaged(i), field6.PointerSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSparseUnmanaged(i), field1.PointerSparseUnmanaged(i), field2.PointerSparseUnmanaged(i), field3.PointerSparseUnmanaged(i), field4.PointerSparseUnmanaged(i), field5.PointerSparseUnmanaged(i), field6.PointerSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSparseSharedUnmanaged(i), field1.PointerSparseSharedUnmanaged(i), field2.PointerSparseSharedUnmanaged(i), field3.PointerSparseSharedUnmanaged(i), field4.PointerSparseSharedUnmanaged(i), field5.PointerSparseSharedUnmanaged(i), field6.PointerSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerManaged(i), field1.PointerManaged(i), field2.PointerManaged(i), field3.PointerManaged(i), field4.PointerManaged(i), field5.PointerManaged(i), field6.PointerManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSharedManaged(i), field1.PointerSharedManaged(i), field2.PointerSharedManaged(i), field3.PointerSharedManaged(i), field4.PointerSharedManaged(i), field5.PointerSharedManaged(i), field6.PointerSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSparseManaged(i), field1.PointerSparseManaged(i), field2.PointerSparseManaged(i), field3.PointerSparseManaged(i), field4.PointerSparseManaged(i), field5.PointerSparseManaged(i), field6.PointerSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSparseSharedManaged(i), field1.PointerSparseSharedManaged(i), field2.PointerSparseSharedManaged(i), field3.PointerSparseSharedManaged(i), field4.PointerSparseSharedManaged(i), field5.PointerSparseSharedManaged(i), field6.PointerSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 
     /// <summary>
@@ -327,25 +1429,135 @@ public static Entity Find<T0, T1, T2, T3, T4, T5, T6>(Iter it, delegate*<Entity,
     {
         int count = it.Handle->count; Ecs.Assert(it.Handle->count > 0, "No entities returned, use Iter() or Each() without the entity argument instead.");
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6);
+        IterationTechnique flags = it.GetIterationTechnique(7);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>())
         {
-            if (!callback(new Entity(it.Handle->world, it.Handle->entities[i]), (T0*)pointer0, (T1*)pointer1, (T2*)pointer2, (T3*)pointer3, (T4*)pointer4, (T5*)pointer5, (T6*)pointer6))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerUnmanaged(i), field1.PointerUnmanaged(i), field2.PointerUnmanaged(i), field3.PointerUnmanaged(i), field4.PointerUnmanaged(i), field5.PointerUnmanaged(i), field6.PointerUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSharedUnmanaged(i), field1.PointerSharedUnmanaged(i), field2.PointerSharedUnmanaged(i), field3.PointerSharedUnmanaged(i), field4.PointerSharedUnmanaged(i), field5.PointerSharedUnmanaged(i), field6.PointerSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseUnmanaged(i), field1.PointerSparseUnmanaged(i), field2.PointerSparseUnmanaged(i), field3.PointerSparseUnmanaged(i), field4.PointerSparseUnmanaged(i), field5.PointerSparseUnmanaged(i), field6.PointerSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseSharedUnmanaged(i), field1.PointerSparseSharedUnmanaged(i), field2.PointerSparseSharedUnmanaged(i), field3.PointerSparseSharedUnmanaged(i), field4.PointerSparseSharedUnmanaged(i), field5.PointerSparseSharedUnmanaged(i), field6.PointerSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerManaged(i), field1.PointerManaged(i), field2.PointerManaged(i), field3.PointerManaged(i), field4.PointerManaged(i), field5.PointerManaged(i), field6.PointerManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSharedManaged(i), field1.PointerSharedManaged(i), field2.PointerSharedManaged(i), field3.PointerSharedManaged(i), field4.PointerSharedManaged(i), field5.PointerSharedManaged(i), field6.PointerSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseManaged(i), field1.PointerSparseManaged(i), field2.PointerSparseManaged(i), field3.PointerSparseManaged(i), field4.PointerSparseManaged(i), field5.PointerSparseManaged(i), field6.PointerSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseSharedManaged(i), field1.PointerSparseSharedManaged(i), field2.PointerSparseSharedManaged(i), field3.PointerSparseSharedManaged(i), field4.PointerSparseSharedManaged(i), field5.PointerSparseSharedManaged(i), field6.PointerSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 
     /// <summary>
@@ -358,24 +1570,134 @@ public static Entity Find<T0, T1, T2, T3, T4, T5, T6>(Iter it, delegate*<Iter, i
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6);
+        IterationTechnique flags = it.GetIterationTechnique(7);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>())
         {
-            if (!callback(it, i, (T0*)pointer0, (T1*)pointer1, (T2*)pointer2, (T3*)pointer3, (T4*)pointer4, (T5*)pointer5, (T6*)pointer6))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerUnmanaged(i), field1.PointerUnmanaged(i), field2.PointerUnmanaged(i), field3.PointerUnmanaged(i), field4.PointerUnmanaged(i), field5.PointerUnmanaged(i), field6.PointerUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSharedUnmanaged(i), field1.PointerSharedUnmanaged(i), field2.PointerSharedUnmanaged(i), field3.PointerSharedUnmanaged(i), field4.PointerSharedUnmanaged(i), field5.PointerSharedUnmanaged(i), field6.PointerSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSparseUnmanaged(i), field1.PointerSparseUnmanaged(i), field2.PointerSparseUnmanaged(i), field3.PointerSparseUnmanaged(i), field4.PointerSparseUnmanaged(i), field5.PointerSparseUnmanaged(i), field6.PointerSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSparseSharedUnmanaged(i), field1.PointerSparseSharedUnmanaged(i), field2.PointerSparseSharedUnmanaged(i), field3.PointerSparseSharedUnmanaged(i), field4.PointerSparseSharedUnmanaged(i), field5.PointerSparseSharedUnmanaged(i), field6.PointerSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerManaged(i), field1.PointerManaged(i), field2.PointerManaged(i), field3.PointerManaged(i), field4.PointerManaged(i), field5.PointerManaged(i), field6.PointerManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSharedManaged(i), field1.PointerSharedManaged(i), field2.PointerSharedManaged(i), field3.PointerSharedManaged(i), field4.PointerSharedManaged(i), field5.PointerSharedManaged(i), field6.PointerSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSparseManaged(i), field1.PointerSparseManaged(i), field2.PointerSparseManaged(i), field3.PointerSparseManaged(i), field4.PointerSparseManaged(i), field5.PointerSparseManaged(i), field6.PointerSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSparseSharedManaged(i), field1.PointerSparseSharedManaged(i), field2.PointerSparseSharedManaged(i), field3.PointerSparseSharedManaged(i), field4.PointerSparseSharedManaged(i), field5.PointerSparseSharedManaged(i), field6.PointerSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 }
\ No newline at end of file
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/Invoker/Find/Iterator/T8.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/Invoker/Find/Iterator/T8.g.cs
index d1d0f073..899e85d8 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/Invoker/Find/Iterator/T8.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/Invoker/Find/Iterator/T8.g.cs
@@ -1,5 +1,7 @@
 // Find/Iterator/T8.g.cs
 // File was auto-generated by /_/src/Flecs.NET.Codegen/Generators/Invoker.cs
+using System;
+using System.Runtime.CompilerServices;
 using Flecs.NET.Utilities;
 using static Flecs.NET.Bindings.flecs;
 
@@ -17,25 +19,135 @@ public static Entity Find<T0, T1, T2, T3, T4, T5, T6, T7>(Iter it, Ecs.FindRefCa
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7);
+        IterationTechnique flags = it.GetIterationTechnique(8);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>())
         {
-            if (!callback(ref Managed.GetTypeRef<T0>(pointer0), ref Managed.GetTypeRef<T1>(pointer1), ref Managed.GetTypeRef<T2>(pointer2), ref Managed.GetTypeRef<T3>(pointer3), ref Managed.GetTypeRef<T4>(pointer4), ref Managed.GetTypeRef<T5>(pointer5), ref Managed.GetTypeRef<T6>(pointer6), ref Managed.GetTypeRef<T7>(pointer7)))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, Ecs.FindRefCallback<T0, T1, T2, T3, T4, T5, T6, T7> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefUnmanaged(i), ref field1.RefUnmanaged(i), ref field2.RefUnmanaged(i), ref field3.RefUnmanaged(i), ref field4.RefUnmanaged(i), ref field5.RefUnmanaged(i), ref field6.RefUnmanaged(i), ref field7.RefUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, Ecs.FindRefCallback<T0, T1, T2, T3, T4, T5, T6, T7> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSharedUnmanaged(i), ref field1.RefSharedUnmanaged(i), ref field2.RefSharedUnmanaged(i), ref field3.RefSharedUnmanaged(i), ref field4.RefSharedUnmanaged(i), ref field5.RefSharedUnmanaged(i), ref field6.RefSharedUnmanaged(i), ref field7.RefSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, Ecs.FindRefCallback<T0, T1, T2, T3, T4, T5, T6, T7> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSparseUnmanaged(i), ref field1.RefSparseUnmanaged(i), ref field2.RefSparseUnmanaged(i), ref field3.RefSparseUnmanaged(i), ref field4.RefSparseUnmanaged(i), ref field5.RefSparseUnmanaged(i), ref field6.RefSparseUnmanaged(i), ref field7.RefSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, Ecs.FindRefCallback<T0, T1, T2, T3, T4, T5, T6, T7> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSparseSharedUnmanaged(i), ref field1.RefSparseSharedUnmanaged(i), ref field2.RefSparseSharedUnmanaged(i), ref field3.RefSparseSharedUnmanaged(i), ref field4.RefSparseSharedUnmanaged(i), ref field5.RefSparseSharedUnmanaged(i), ref field6.RefSparseSharedUnmanaged(i), ref field7.RefSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, Ecs.FindRefCallback<T0, T1, T2, T3, T4, T5, T6, T7> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefManaged(i), ref field1.RefManaged(i), ref field2.RefManaged(i), ref field3.RefManaged(i), ref field4.RefManaged(i), ref field5.RefManaged(i), ref field6.RefManaged(i), ref field7.RefManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, Ecs.FindRefCallback<T0, T1, T2, T3, T4, T5, T6, T7> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSharedManaged(i), ref field1.RefSharedManaged(i), ref field2.RefSharedManaged(i), ref field3.RefSharedManaged(i), ref field4.RefSharedManaged(i), ref field5.RefSharedManaged(i), ref field6.RefSharedManaged(i), ref field7.RefSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, Ecs.FindRefCallback<T0, T1, T2, T3, T4, T5, T6, T7> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSparseManaged(i), ref field1.RefSparseManaged(i), ref field2.RefSparseManaged(i), ref field3.RefSparseManaged(i), ref field4.RefSparseManaged(i), ref field5.RefSparseManaged(i), ref field6.RefSparseManaged(i), ref field7.RefSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, Ecs.FindRefCallback<T0, T1, T2, T3, T4, T5, T6, T7> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSparseSharedManaged(i), ref field1.RefSparseSharedManaged(i), ref field2.RefSparseSharedManaged(i), ref field3.RefSparseSharedManaged(i), ref field4.RefSparseSharedManaged(i), ref field5.RefSparseSharedManaged(i), ref field6.RefSparseSharedManaged(i), ref field7.RefSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 
     /// <summary>
@@ -48,25 +160,135 @@ public static Entity Find<T0, T1, T2, T3, T4, T5, T6, T7>(Iter it, Ecs.FindEntit
     {
         int count = it.Handle->count; Ecs.Assert(it.Handle->count > 0, "No entities returned, use Iter() or Each() without the entity argument instead.");
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7);
+        IterationTechnique flags = it.GetIterationTechnique(8);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>())
         {
-            if (!callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref Managed.GetTypeRef<T0>(pointer0), ref Managed.GetTypeRef<T1>(pointer1), ref Managed.GetTypeRef<T2>(pointer2), ref Managed.GetTypeRef<T3>(pointer3), ref Managed.GetTypeRef<T4>(pointer4), ref Managed.GetTypeRef<T5>(pointer5), ref Managed.GetTypeRef<T6>(pointer6), ref Managed.GetTypeRef<T7>(pointer7)))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefUnmanaged(i), ref field1.RefUnmanaged(i), ref field2.RefUnmanaged(i), ref field3.RefUnmanaged(i), ref field4.RefUnmanaged(i), ref field5.RefUnmanaged(i), ref field6.RefUnmanaged(i), ref field7.RefUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSharedUnmanaged(i), ref field1.RefSharedUnmanaged(i), ref field2.RefSharedUnmanaged(i), ref field3.RefSharedUnmanaged(i), ref field4.RefSharedUnmanaged(i), ref field5.RefSharedUnmanaged(i), ref field6.RefSharedUnmanaged(i), ref field7.RefSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseUnmanaged(i), ref field1.RefSparseUnmanaged(i), ref field2.RefSparseUnmanaged(i), ref field3.RefSparseUnmanaged(i), ref field4.RefSparseUnmanaged(i), ref field5.RefSparseUnmanaged(i), ref field6.RefSparseUnmanaged(i), ref field7.RefSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseSharedUnmanaged(i), ref field1.RefSparseSharedUnmanaged(i), ref field2.RefSparseSharedUnmanaged(i), ref field3.RefSparseSharedUnmanaged(i), ref field4.RefSparseSharedUnmanaged(i), ref field5.RefSparseSharedUnmanaged(i), ref field6.RefSparseSharedUnmanaged(i), ref field7.RefSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefManaged(i), ref field1.RefManaged(i), ref field2.RefManaged(i), ref field3.RefManaged(i), ref field4.RefManaged(i), ref field5.RefManaged(i), ref field6.RefManaged(i), ref field7.RefManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSharedManaged(i), ref field1.RefSharedManaged(i), ref field2.RefSharedManaged(i), ref field3.RefSharedManaged(i), ref field4.RefSharedManaged(i), ref field5.RefSharedManaged(i), ref field6.RefSharedManaged(i), ref field7.RefSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseManaged(i), ref field1.RefSparseManaged(i), ref field2.RefSparseManaged(i), ref field3.RefSparseManaged(i), ref field4.RefSparseManaged(i), ref field5.RefSparseManaged(i), ref field6.RefSparseManaged(i), ref field7.RefSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseSharedManaged(i), ref field1.RefSparseSharedManaged(i), ref field2.RefSparseSharedManaged(i), ref field3.RefSparseSharedManaged(i), ref field4.RefSparseSharedManaged(i), ref field5.RefSparseSharedManaged(i), ref field6.RefSparseSharedManaged(i), ref field7.RefSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 
     /// <summary>
@@ -79,25 +301,135 @@ public static Entity Find<T0, T1, T2, T3, T4, T5, T6, T7>(Iter it, Ecs.FindIterR
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7);
+        IterationTechnique flags = it.GetIterationTechnique(8);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>())
         {
-            if (!callback(it, i, ref Managed.GetTypeRef<T0>(pointer0), ref Managed.GetTypeRef<T1>(pointer1), ref Managed.GetTypeRef<T2>(pointer2), ref Managed.GetTypeRef<T3>(pointer3), ref Managed.GetTypeRef<T4>(pointer4), ref Managed.GetTypeRef<T5>(pointer5), ref Managed.GetTypeRef<T6>(pointer6), ref Managed.GetTypeRef<T7>(pointer7)))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, Ecs.FindIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefUnmanaged(i), ref field1.RefUnmanaged(i), ref field2.RefUnmanaged(i), ref field3.RefUnmanaged(i), ref field4.RefUnmanaged(i), ref field5.RefUnmanaged(i), ref field6.RefUnmanaged(i), ref field7.RefUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, Ecs.FindIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSharedUnmanaged(i), ref field1.RefSharedUnmanaged(i), ref field2.RefSharedUnmanaged(i), ref field3.RefSharedUnmanaged(i), ref field4.RefSharedUnmanaged(i), ref field5.RefSharedUnmanaged(i), ref field6.RefSharedUnmanaged(i), ref field7.RefSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, Ecs.FindIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSparseUnmanaged(i), ref field1.RefSparseUnmanaged(i), ref field2.RefSparseUnmanaged(i), ref field3.RefSparseUnmanaged(i), ref field4.RefSparseUnmanaged(i), ref field5.RefSparseUnmanaged(i), ref field6.RefSparseUnmanaged(i), ref field7.RefSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, Ecs.FindIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSparseSharedUnmanaged(i), ref field1.RefSparseSharedUnmanaged(i), ref field2.RefSparseSharedUnmanaged(i), ref field3.RefSparseSharedUnmanaged(i), ref field4.RefSparseSharedUnmanaged(i), ref field5.RefSparseSharedUnmanaged(i), ref field6.RefSparseSharedUnmanaged(i), ref field7.RefSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, Ecs.FindIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefManaged(i), ref field1.RefManaged(i), ref field2.RefManaged(i), ref field3.RefManaged(i), ref field4.RefManaged(i), ref field5.RefManaged(i), ref field6.RefManaged(i), ref field7.RefManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, Ecs.FindIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSharedManaged(i), ref field1.RefSharedManaged(i), ref field2.RefSharedManaged(i), ref field3.RefSharedManaged(i), ref field4.RefSharedManaged(i), ref field5.RefSharedManaged(i), ref field6.RefSharedManaged(i), ref field7.RefSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, Ecs.FindIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSparseManaged(i), ref field1.RefSparseManaged(i), ref field2.RefSparseManaged(i), ref field3.RefSparseManaged(i), ref field4.RefSparseManaged(i), ref field5.RefSparseManaged(i), ref field6.RefSparseManaged(i), ref field7.RefSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, Ecs.FindIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSparseSharedManaged(i), ref field1.RefSparseSharedManaged(i), ref field2.RefSparseSharedManaged(i), ref field3.RefSparseSharedManaged(i), ref field4.RefSparseSharedManaged(i), ref field5.RefSparseSharedManaged(i), ref field6.RefSparseSharedManaged(i), ref field7.RefSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 
     /// <summary>
@@ -110,25 +442,135 @@ public static Entity Find<T0, T1, T2, T3, T4, T5, T6, T7>(Iter it, delegate*<ref
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7);
+        IterationTechnique flags = it.GetIterationTechnique(8);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>())
         {
-            if (!callback(ref Managed.GetTypeRef<T0>(pointer0), ref Managed.GetTypeRef<T1>(pointer1), ref Managed.GetTypeRef<T2>(pointer2), ref Managed.GetTypeRef<T3>(pointer3), ref Managed.GetTypeRef<T4>(pointer4), ref Managed.GetTypeRef<T5>(pointer5), ref Managed.GetTypeRef<T6>(pointer6), ref Managed.GetTypeRef<T7>(pointer7)))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefUnmanaged(i), ref field1.RefUnmanaged(i), ref field2.RefUnmanaged(i), ref field3.RefUnmanaged(i), ref field4.RefUnmanaged(i), ref field5.RefUnmanaged(i), ref field6.RefUnmanaged(i), ref field7.RefUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSharedUnmanaged(i), ref field1.RefSharedUnmanaged(i), ref field2.RefSharedUnmanaged(i), ref field3.RefSharedUnmanaged(i), ref field4.RefSharedUnmanaged(i), ref field5.RefSharedUnmanaged(i), ref field6.RefSharedUnmanaged(i), ref field7.RefSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSparseUnmanaged(i), ref field1.RefSparseUnmanaged(i), ref field2.RefSparseUnmanaged(i), ref field3.RefSparseUnmanaged(i), ref field4.RefSparseUnmanaged(i), ref field5.RefSparseUnmanaged(i), ref field6.RefSparseUnmanaged(i), ref field7.RefSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSparseSharedUnmanaged(i), ref field1.RefSparseSharedUnmanaged(i), ref field2.RefSparseSharedUnmanaged(i), ref field3.RefSparseSharedUnmanaged(i), ref field4.RefSparseSharedUnmanaged(i), ref field5.RefSparseSharedUnmanaged(i), ref field6.RefSparseSharedUnmanaged(i), ref field7.RefSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefManaged(i), ref field1.RefManaged(i), ref field2.RefManaged(i), ref field3.RefManaged(i), ref field4.RefManaged(i), ref field5.RefManaged(i), ref field6.RefManaged(i), ref field7.RefManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSharedManaged(i), ref field1.RefSharedManaged(i), ref field2.RefSharedManaged(i), ref field3.RefSharedManaged(i), ref field4.RefSharedManaged(i), ref field5.RefSharedManaged(i), ref field6.RefSharedManaged(i), ref field7.RefSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSparseManaged(i), ref field1.RefSparseManaged(i), ref field2.RefSparseManaged(i), ref field3.RefSparseManaged(i), ref field4.RefSparseManaged(i), ref field5.RefSparseManaged(i), ref field6.RefSparseManaged(i), ref field7.RefSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSparseSharedManaged(i), ref field1.RefSparseSharedManaged(i), ref field2.RefSparseSharedManaged(i), ref field3.RefSparseSharedManaged(i), ref field4.RefSparseSharedManaged(i), ref field5.RefSparseSharedManaged(i), ref field6.RefSparseSharedManaged(i), ref field7.RefSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 
     /// <summary>
@@ -141,25 +583,135 @@ public static Entity Find<T0, T1, T2, T3, T4, T5, T6, T7>(Iter it, delegate*<Ent
     {
         int count = it.Handle->count; Ecs.Assert(it.Handle->count > 0, "No entities returned, use Iter() or Each() without the entity argument instead.");
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7);
+        IterationTechnique flags = it.GetIterationTechnique(8);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>())
         {
-            if (!callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref Managed.GetTypeRef<T0>(pointer0), ref Managed.GetTypeRef<T1>(pointer1), ref Managed.GetTypeRef<T2>(pointer2), ref Managed.GetTypeRef<T3>(pointer3), ref Managed.GetTypeRef<T4>(pointer4), ref Managed.GetTypeRef<T5>(pointer5), ref Managed.GetTypeRef<T6>(pointer6), ref Managed.GetTypeRef<T7>(pointer7)))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefUnmanaged(i), ref field1.RefUnmanaged(i), ref field2.RefUnmanaged(i), ref field3.RefUnmanaged(i), ref field4.RefUnmanaged(i), ref field5.RefUnmanaged(i), ref field6.RefUnmanaged(i), ref field7.RefUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSharedUnmanaged(i), ref field1.RefSharedUnmanaged(i), ref field2.RefSharedUnmanaged(i), ref field3.RefSharedUnmanaged(i), ref field4.RefSharedUnmanaged(i), ref field5.RefSharedUnmanaged(i), ref field6.RefSharedUnmanaged(i), ref field7.RefSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseUnmanaged(i), ref field1.RefSparseUnmanaged(i), ref field2.RefSparseUnmanaged(i), ref field3.RefSparseUnmanaged(i), ref field4.RefSparseUnmanaged(i), ref field5.RefSparseUnmanaged(i), ref field6.RefSparseUnmanaged(i), ref field7.RefSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseSharedUnmanaged(i), ref field1.RefSparseSharedUnmanaged(i), ref field2.RefSparseSharedUnmanaged(i), ref field3.RefSparseSharedUnmanaged(i), ref field4.RefSparseSharedUnmanaged(i), ref field5.RefSparseSharedUnmanaged(i), ref field6.RefSparseSharedUnmanaged(i), ref field7.RefSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefManaged(i), ref field1.RefManaged(i), ref field2.RefManaged(i), ref field3.RefManaged(i), ref field4.RefManaged(i), ref field5.RefManaged(i), ref field6.RefManaged(i), ref field7.RefManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSharedManaged(i), ref field1.RefSharedManaged(i), ref field2.RefSharedManaged(i), ref field3.RefSharedManaged(i), ref field4.RefSharedManaged(i), ref field5.RefSharedManaged(i), ref field6.RefSharedManaged(i), ref field7.RefSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseManaged(i), ref field1.RefSparseManaged(i), ref field2.RefSparseManaged(i), ref field3.RefSparseManaged(i), ref field4.RefSparseManaged(i), ref field5.RefSparseManaged(i), ref field6.RefSparseManaged(i), ref field7.RefSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseSharedManaged(i), ref field1.RefSparseSharedManaged(i), ref field2.RefSparseSharedManaged(i), ref field3.RefSparseSharedManaged(i), ref field4.RefSparseSharedManaged(i), ref field5.RefSparseSharedManaged(i), ref field6.RefSparseSharedManaged(i), ref field7.RefSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 
     /// <summary>
@@ -172,25 +724,135 @@ public static Entity Find<T0, T1, T2, T3, T4, T5, T6, T7>(Iter it, delegate*<Ite
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7);
+        IterationTechnique flags = it.GetIterationTechnique(8);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>())
         {
-            if (!callback(it, i, ref Managed.GetTypeRef<T0>(pointer0), ref Managed.GetTypeRef<T1>(pointer1), ref Managed.GetTypeRef<T2>(pointer2), ref Managed.GetTypeRef<T3>(pointer3), ref Managed.GetTypeRef<T4>(pointer4), ref Managed.GetTypeRef<T5>(pointer5), ref Managed.GetTypeRef<T6>(pointer6), ref Managed.GetTypeRef<T7>(pointer7)))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefUnmanaged(i), ref field1.RefUnmanaged(i), ref field2.RefUnmanaged(i), ref field3.RefUnmanaged(i), ref field4.RefUnmanaged(i), ref field5.RefUnmanaged(i), ref field6.RefUnmanaged(i), ref field7.RefUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSharedUnmanaged(i), ref field1.RefSharedUnmanaged(i), ref field2.RefSharedUnmanaged(i), ref field3.RefSharedUnmanaged(i), ref field4.RefSharedUnmanaged(i), ref field5.RefSharedUnmanaged(i), ref field6.RefSharedUnmanaged(i), ref field7.RefSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSparseUnmanaged(i), ref field1.RefSparseUnmanaged(i), ref field2.RefSparseUnmanaged(i), ref field3.RefSparseUnmanaged(i), ref field4.RefSparseUnmanaged(i), ref field5.RefSparseUnmanaged(i), ref field6.RefSparseUnmanaged(i), ref field7.RefSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSparseSharedUnmanaged(i), ref field1.RefSparseSharedUnmanaged(i), ref field2.RefSparseSharedUnmanaged(i), ref field3.RefSparseSharedUnmanaged(i), ref field4.RefSparseSharedUnmanaged(i), ref field5.RefSparseSharedUnmanaged(i), ref field6.RefSparseSharedUnmanaged(i), ref field7.RefSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefManaged(i), ref field1.RefManaged(i), ref field2.RefManaged(i), ref field3.RefManaged(i), ref field4.RefManaged(i), ref field5.RefManaged(i), ref field6.RefManaged(i), ref field7.RefManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSharedManaged(i), ref field1.RefSharedManaged(i), ref field2.RefSharedManaged(i), ref field3.RefSharedManaged(i), ref field4.RefSharedManaged(i), ref field5.RefSharedManaged(i), ref field6.RefSharedManaged(i), ref field7.RefSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSparseManaged(i), ref field1.RefSparseManaged(i), ref field2.RefSparseManaged(i), ref field3.RefSparseManaged(i), ref field4.RefSparseManaged(i), ref field5.RefSparseManaged(i), ref field6.RefSparseManaged(i), ref field7.RefSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSparseSharedManaged(i), ref field1.RefSparseSharedManaged(i), ref field2.RefSparseSharedManaged(i), ref field3.RefSparseSharedManaged(i), ref field4.RefSparseSharedManaged(i), ref field5.RefSparseSharedManaged(i), ref field6.RefSparseSharedManaged(i), ref field7.RefSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 
     /// <summary>
@@ -203,25 +865,135 @@ public static Entity Find<T0, T1, T2, T3, T4, T5, T6, T7>(Iter it, Ecs.FindPoint
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7);
+        IterationTechnique flags = it.GetIterationTechnique(8);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>())
         {
-            if (!callback((T0*)pointer0, (T1*)pointer1, (T2*)pointer2, (T3*)pointer3, (T4*)pointer4, (T5*)pointer5, (T6*)pointer6, (T7*)pointer7))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, Ecs.FindPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerUnmanaged(i), field1.PointerUnmanaged(i), field2.PointerUnmanaged(i), field3.PointerUnmanaged(i), field4.PointerUnmanaged(i), field5.PointerUnmanaged(i), field6.PointerUnmanaged(i), field7.PointerUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, Ecs.FindPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSharedUnmanaged(i), field1.PointerSharedUnmanaged(i), field2.PointerSharedUnmanaged(i), field3.PointerSharedUnmanaged(i), field4.PointerSharedUnmanaged(i), field5.PointerSharedUnmanaged(i), field6.PointerSharedUnmanaged(i), field7.PointerSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, Ecs.FindPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSparseUnmanaged(i), field1.PointerSparseUnmanaged(i), field2.PointerSparseUnmanaged(i), field3.PointerSparseUnmanaged(i), field4.PointerSparseUnmanaged(i), field5.PointerSparseUnmanaged(i), field6.PointerSparseUnmanaged(i), field7.PointerSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, Ecs.FindPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSparseSharedUnmanaged(i), field1.PointerSparseSharedUnmanaged(i), field2.PointerSparseSharedUnmanaged(i), field3.PointerSparseSharedUnmanaged(i), field4.PointerSparseSharedUnmanaged(i), field5.PointerSparseSharedUnmanaged(i), field6.PointerSparseSharedUnmanaged(i), field7.PointerSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, Ecs.FindPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerManaged(i), field1.PointerManaged(i), field2.PointerManaged(i), field3.PointerManaged(i), field4.PointerManaged(i), field5.PointerManaged(i), field6.PointerManaged(i), field7.PointerManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, Ecs.FindPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSharedManaged(i), field1.PointerSharedManaged(i), field2.PointerSharedManaged(i), field3.PointerSharedManaged(i), field4.PointerSharedManaged(i), field5.PointerSharedManaged(i), field6.PointerSharedManaged(i), field7.PointerSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, Ecs.FindPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSparseManaged(i), field1.PointerSparseManaged(i), field2.PointerSparseManaged(i), field3.PointerSparseManaged(i), field4.PointerSparseManaged(i), field5.PointerSparseManaged(i), field6.PointerSparseManaged(i), field7.PointerSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, Ecs.FindPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSparseSharedManaged(i), field1.PointerSparseSharedManaged(i), field2.PointerSparseSharedManaged(i), field3.PointerSparseSharedManaged(i), field4.PointerSparseSharedManaged(i), field5.PointerSparseSharedManaged(i), field6.PointerSparseSharedManaged(i), field7.PointerSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 
     /// <summary>
@@ -234,25 +1006,135 @@ public static Entity Find<T0, T1, T2, T3, T4, T5, T6, T7>(Iter it, Ecs.FindEntit
     {
         int count = it.Handle->count; Ecs.Assert(it.Handle->count > 0, "No entities returned, use Iter() or Each() without the entity argument instead.");
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7);
+        IterationTechnique flags = it.GetIterationTechnique(8);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>())
         {
-            if (!callback(new Entity(it.Handle->world, it.Handle->entities[i]), (T0*)pointer0, (T1*)pointer1, (T2*)pointer2, (T3*)pointer3, (T4*)pointer4, (T5*)pointer5, (T6*)pointer6, (T7*)pointer7))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerUnmanaged(i), field1.PointerUnmanaged(i), field2.PointerUnmanaged(i), field3.PointerUnmanaged(i), field4.PointerUnmanaged(i), field5.PointerUnmanaged(i), field6.PointerUnmanaged(i), field7.PointerUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSharedUnmanaged(i), field1.PointerSharedUnmanaged(i), field2.PointerSharedUnmanaged(i), field3.PointerSharedUnmanaged(i), field4.PointerSharedUnmanaged(i), field5.PointerSharedUnmanaged(i), field6.PointerSharedUnmanaged(i), field7.PointerSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseUnmanaged(i), field1.PointerSparseUnmanaged(i), field2.PointerSparseUnmanaged(i), field3.PointerSparseUnmanaged(i), field4.PointerSparseUnmanaged(i), field5.PointerSparseUnmanaged(i), field6.PointerSparseUnmanaged(i), field7.PointerSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseSharedUnmanaged(i), field1.PointerSparseSharedUnmanaged(i), field2.PointerSparseSharedUnmanaged(i), field3.PointerSparseSharedUnmanaged(i), field4.PointerSparseSharedUnmanaged(i), field5.PointerSparseSharedUnmanaged(i), field6.PointerSparseSharedUnmanaged(i), field7.PointerSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerManaged(i), field1.PointerManaged(i), field2.PointerManaged(i), field3.PointerManaged(i), field4.PointerManaged(i), field5.PointerManaged(i), field6.PointerManaged(i), field7.PointerManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSharedManaged(i), field1.PointerSharedManaged(i), field2.PointerSharedManaged(i), field3.PointerSharedManaged(i), field4.PointerSharedManaged(i), field5.PointerSharedManaged(i), field6.PointerSharedManaged(i), field7.PointerSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseManaged(i), field1.PointerSparseManaged(i), field2.PointerSparseManaged(i), field3.PointerSparseManaged(i), field4.PointerSparseManaged(i), field5.PointerSparseManaged(i), field6.PointerSparseManaged(i), field7.PointerSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseSharedManaged(i), field1.PointerSparseSharedManaged(i), field2.PointerSparseSharedManaged(i), field3.PointerSparseSharedManaged(i), field4.PointerSparseSharedManaged(i), field5.PointerSparseSharedManaged(i), field6.PointerSparseSharedManaged(i), field7.PointerSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 
     /// <summary>
@@ -265,25 +1147,135 @@ public static Entity Find<T0, T1, T2, T3, T4, T5, T6, T7>(Iter it, Ecs.FindIterP
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7);
+        IterationTechnique flags = it.GetIterationTechnique(8);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>())
         {
-            if (!callback(it, i, (T0*)pointer0, (T1*)pointer1, (T2*)pointer2, (T3*)pointer3, (T4*)pointer4, (T5*)pointer5, (T6*)pointer6, (T7*)pointer7))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerUnmanaged(i), field1.PointerUnmanaged(i), field2.PointerUnmanaged(i), field3.PointerUnmanaged(i), field4.PointerUnmanaged(i), field5.PointerUnmanaged(i), field6.PointerUnmanaged(i), field7.PointerUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSharedUnmanaged(i), field1.PointerSharedUnmanaged(i), field2.PointerSharedUnmanaged(i), field3.PointerSharedUnmanaged(i), field4.PointerSharedUnmanaged(i), field5.PointerSharedUnmanaged(i), field6.PointerSharedUnmanaged(i), field7.PointerSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSparseUnmanaged(i), field1.PointerSparseUnmanaged(i), field2.PointerSparseUnmanaged(i), field3.PointerSparseUnmanaged(i), field4.PointerSparseUnmanaged(i), field5.PointerSparseUnmanaged(i), field6.PointerSparseUnmanaged(i), field7.PointerSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSparseSharedUnmanaged(i), field1.PointerSparseSharedUnmanaged(i), field2.PointerSparseSharedUnmanaged(i), field3.PointerSparseSharedUnmanaged(i), field4.PointerSparseSharedUnmanaged(i), field5.PointerSparseSharedUnmanaged(i), field6.PointerSparseSharedUnmanaged(i), field7.PointerSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerManaged(i), field1.PointerManaged(i), field2.PointerManaged(i), field3.PointerManaged(i), field4.PointerManaged(i), field5.PointerManaged(i), field6.PointerManaged(i), field7.PointerManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSharedManaged(i), field1.PointerSharedManaged(i), field2.PointerSharedManaged(i), field3.PointerSharedManaged(i), field4.PointerSharedManaged(i), field5.PointerSharedManaged(i), field6.PointerSharedManaged(i), field7.PointerSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSparseManaged(i), field1.PointerSparseManaged(i), field2.PointerSparseManaged(i), field3.PointerSparseManaged(i), field4.PointerSparseManaged(i), field5.PointerSparseManaged(i), field6.PointerSparseManaged(i), field7.PointerSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSparseSharedManaged(i), field1.PointerSparseSharedManaged(i), field2.PointerSparseSharedManaged(i), field3.PointerSparseSharedManaged(i), field4.PointerSparseSharedManaged(i), field5.PointerSparseSharedManaged(i), field6.PointerSparseSharedManaged(i), field7.PointerSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 
     /// <summary>
@@ -296,25 +1288,135 @@ public static Entity Find<T0, T1, T2, T3, T4, T5, T6, T7>(Iter it, delegate*<T0*
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7);
+        IterationTechnique flags = it.GetIterationTechnique(8);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>())
         {
-            if (!callback((T0*)pointer0, (T1*)pointer1, (T2*)pointer2, (T3*)pointer3, (T4*)pointer4, (T5*)pointer5, (T6*)pointer6, (T7*)pointer7))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerUnmanaged(i), field1.PointerUnmanaged(i), field2.PointerUnmanaged(i), field3.PointerUnmanaged(i), field4.PointerUnmanaged(i), field5.PointerUnmanaged(i), field6.PointerUnmanaged(i), field7.PointerUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSharedUnmanaged(i), field1.PointerSharedUnmanaged(i), field2.PointerSharedUnmanaged(i), field3.PointerSharedUnmanaged(i), field4.PointerSharedUnmanaged(i), field5.PointerSharedUnmanaged(i), field6.PointerSharedUnmanaged(i), field7.PointerSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSparseUnmanaged(i), field1.PointerSparseUnmanaged(i), field2.PointerSparseUnmanaged(i), field3.PointerSparseUnmanaged(i), field4.PointerSparseUnmanaged(i), field5.PointerSparseUnmanaged(i), field6.PointerSparseUnmanaged(i), field7.PointerSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSparseSharedUnmanaged(i), field1.PointerSparseSharedUnmanaged(i), field2.PointerSparseSharedUnmanaged(i), field3.PointerSparseSharedUnmanaged(i), field4.PointerSparseSharedUnmanaged(i), field5.PointerSparseSharedUnmanaged(i), field6.PointerSparseSharedUnmanaged(i), field7.PointerSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerManaged(i), field1.PointerManaged(i), field2.PointerManaged(i), field3.PointerManaged(i), field4.PointerManaged(i), field5.PointerManaged(i), field6.PointerManaged(i), field7.PointerManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSharedManaged(i), field1.PointerSharedManaged(i), field2.PointerSharedManaged(i), field3.PointerSharedManaged(i), field4.PointerSharedManaged(i), field5.PointerSharedManaged(i), field6.PointerSharedManaged(i), field7.PointerSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSparseManaged(i), field1.PointerSparseManaged(i), field2.PointerSparseManaged(i), field3.PointerSparseManaged(i), field4.PointerSparseManaged(i), field5.PointerSparseManaged(i), field6.PointerSparseManaged(i), field7.PointerSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSparseSharedManaged(i), field1.PointerSparseSharedManaged(i), field2.PointerSparseSharedManaged(i), field3.PointerSparseSharedManaged(i), field4.PointerSparseSharedManaged(i), field5.PointerSparseSharedManaged(i), field6.PointerSparseSharedManaged(i), field7.PointerSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 
     /// <summary>
@@ -327,25 +1429,135 @@ public static Entity Find<T0, T1, T2, T3, T4, T5, T6, T7>(Iter it, delegate*<Ent
     {
         int count = it.Handle->count; Ecs.Assert(it.Handle->count > 0, "No entities returned, use Iter() or Each() without the entity argument instead.");
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7);
+        IterationTechnique flags = it.GetIterationTechnique(8);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>())
         {
-            if (!callback(new Entity(it.Handle->world, it.Handle->entities[i]), (T0*)pointer0, (T1*)pointer1, (T2*)pointer2, (T3*)pointer3, (T4*)pointer4, (T5*)pointer5, (T6*)pointer6, (T7*)pointer7))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerUnmanaged(i), field1.PointerUnmanaged(i), field2.PointerUnmanaged(i), field3.PointerUnmanaged(i), field4.PointerUnmanaged(i), field5.PointerUnmanaged(i), field6.PointerUnmanaged(i), field7.PointerUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSharedUnmanaged(i), field1.PointerSharedUnmanaged(i), field2.PointerSharedUnmanaged(i), field3.PointerSharedUnmanaged(i), field4.PointerSharedUnmanaged(i), field5.PointerSharedUnmanaged(i), field6.PointerSharedUnmanaged(i), field7.PointerSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseUnmanaged(i), field1.PointerSparseUnmanaged(i), field2.PointerSparseUnmanaged(i), field3.PointerSparseUnmanaged(i), field4.PointerSparseUnmanaged(i), field5.PointerSparseUnmanaged(i), field6.PointerSparseUnmanaged(i), field7.PointerSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseSharedUnmanaged(i), field1.PointerSparseSharedUnmanaged(i), field2.PointerSparseSharedUnmanaged(i), field3.PointerSparseSharedUnmanaged(i), field4.PointerSparseSharedUnmanaged(i), field5.PointerSparseSharedUnmanaged(i), field6.PointerSparseSharedUnmanaged(i), field7.PointerSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerManaged(i), field1.PointerManaged(i), field2.PointerManaged(i), field3.PointerManaged(i), field4.PointerManaged(i), field5.PointerManaged(i), field6.PointerManaged(i), field7.PointerManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSharedManaged(i), field1.PointerSharedManaged(i), field2.PointerSharedManaged(i), field3.PointerSharedManaged(i), field4.PointerSharedManaged(i), field5.PointerSharedManaged(i), field6.PointerSharedManaged(i), field7.PointerSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseManaged(i), field1.PointerSparseManaged(i), field2.PointerSparseManaged(i), field3.PointerSparseManaged(i), field4.PointerSparseManaged(i), field5.PointerSparseManaged(i), field6.PointerSparseManaged(i), field7.PointerSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseSharedManaged(i), field1.PointerSparseSharedManaged(i), field2.PointerSparseSharedManaged(i), field3.PointerSparseSharedManaged(i), field4.PointerSparseSharedManaged(i), field5.PointerSparseSharedManaged(i), field6.PointerSparseSharedManaged(i), field7.PointerSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 
     /// <summary>
@@ -358,24 +1570,134 @@ public static Entity Find<T0, T1, T2, T3, T4, T5, T6, T7>(Iter it, delegate*<Ite
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7);
+        IterationTechnique flags = it.GetIterationTechnique(8);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>())
         {
-            if (!callback(it, i, (T0*)pointer0, (T1*)pointer1, (T2*)pointer2, (T3*)pointer3, (T4*)pointer4, (T5*)pointer5, (T6*)pointer6, (T7*)pointer7))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerUnmanaged(i), field1.PointerUnmanaged(i), field2.PointerUnmanaged(i), field3.PointerUnmanaged(i), field4.PointerUnmanaged(i), field5.PointerUnmanaged(i), field6.PointerUnmanaged(i), field7.PointerUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSharedUnmanaged(i), field1.PointerSharedUnmanaged(i), field2.PointerSharedUnmanaged(i), field3.PointerSharedUnmanaged(i), field4.PointerSharedUnmanaged(i), field5.PointerSharedUnmanaged(i), field6.PointerSharedUnmanaged(i), field7.PointerSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSparseUnmanaged(i), field1.PointerSparseUnmanaged(i), field2.PointerSparseUnmanaged(i), field3.PointerSparseUnmanaged(i), field4.PointerSparseUnmanaged(i), field5.PointerSparseUnmanaged(i), field6.PointerSparseUnmanaged(i), field7.PointerSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSparseSharedUnmanaged(i), field1.PointerSparseSharedUnmanaged(i), field2.PointerSparseSharedUnmanaged(i), field3.PointerSparseSharedUnmanaged(i), field4.PointerSparseSharedUnmanaged(i), field5.PointerSparseSharedUnmanaged(i), field6.PointerSparseSharedUnmanaged(i), field7.PointerSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerManaged(i), field1.PointerManaged(i), field2.PointerManaged(i), field3.PointerManaged(i), field4.PointerManaged(i), field5.PointerManaged(i), field6.PointerManaged(i), field7.PointerManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSharedManaged(i), field1.PointerSharedManaged(i), field2.PointerSharedManaged(i), field3.PointerSharedManaged(i), field4.PointerSharedManaged(i), field5.PointerSharedManaged(i), field6.PointerSharedManaged(i), field7.PointerSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSparseManaged(i), field1.PointerSparseManaged(i), field2.PointerSparseManaged(i), field3.PointerSparseManaged(i), field4.PointerSparseManaged(i), field5.PointerSparseManaged(i), field6.PointerSparseManaged(i), field7.PointerSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSparseSharedManaged(i), field1.PointerSparseSharedManaged(i), field2.PointerSparseSharedManaged(i), field3.PointerSparseSharedManaged(i), field4.PointerSparseSharedManaged(i), field5.PointerSparseSharedManaged(i), field6.PointerSparseSharedManaged(i), field7.PointerSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 }
\ No newline at end of file
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/Invoker/Find/Iterator/T9.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/Invoker/Find/Iterator/T9.g.cs
index 8f830ae6..046be269 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/Invoker/Find/Iterator/T9.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/Invoker/Find/Iterator/T9.g.cs
@@ -1,5 +1,7 @@
 // Find/Iterator/T9.g.cs
 // File was auto-generated by /_/src/Flecs.NET.Codegen/Generators/Invoker.cs
+using System;
+using System.Runtime.CompilerServices;
 using Flecs.NET.Utilities;
 using static Flecs.NET.Bindings.flecs;
 
@@ -17,25 +19,135 @@ public static Entity Find<T0, T1, T2, T3, T4, T5, T6, T7, T8>(Iter it, Ecs.FindR
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8);
+        IterationTechnique flags = it.GetIterationTechnique(9);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>())
         {
-            if (!callback(ref Managed.GetTypeRef<T0>(pointer0), ref Managed.GetTypeRef<T1>(pointer1), ref Managed.GetTypeRef<T2>(pointer2), ref Managed.GetTypeRef<T3>(pointer3), ref Managed.GetTypeRef<T4>(pointer4), ref Managed.GetTypeRef<T5>(pointer5), ref Managed.GetTypeRef<T6>(pointer6), ref Managed.GetTypeRef<T7>(pointer7), ref Managed.GetTypeRef<T8>(pointer8)))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, Ecs.FindRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefUnmanaged(i), ref field1.RefUnmanaged(i), ref field2.RefUnmanaged(i), ref field3.RefUnmanaged(i), ref field4.RefUnmanaged(i), ref field5.RefUnmanaged(i), ref field6.RefUnmanaged(i), ref field7.RefUnmanaged(i), ref field8.RefUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, Ecs.FindRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSharedUnmanaged(i), ref field1.RefSharedUnmanaged(i), ref field2.RefSharedUnmanaged(i), ref field3.RefSharedUnmanaged(i), ref field4.RefSharedUnmanaged(i), ref field5.RefSharedUnmanaged(i), ref field6.RefSharedUnmanaged(i), ref field7.RefSharedUnmanaged(i), ref field8.RefSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, Ecs.FindRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSparseUnmanaged(i), ref field1.RefSparseUnmanaged(i), ref field2.RefSparseUnmanaged(i), ref field3.RefSparseUnmanaged(i), ref field4.RefSparseUnmanaged(i), ref field5.RefSparseUnmanaged(i), ref field6.RefSparseUnmanaged(i), ref field7.RefSparseUnmanaged(i), ref field8.RefSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, Ecs.FindRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSparseSharedUnmanaged(i), ref field1.RefSparseSharedUnmanaged(i), ref field2.RefSparseSharedUnmanaged(i), ref field3.RefSparseSharedUnmanaged(i), ref field4.RefSparseSharedUnmanaged(i), ref field5.RefSparseSharedUnmanaged(i), ref field6.RefSparseSharedUnmanaged(i), ref field7.RefSparseSharedUnmanaged(i), ref field8.RefSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, Ecs.FindRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefManaged(i), ref field1.RefManaged(i), ref field2.RefManaged(i), ref field3.RefManaged(i), ref field4.RefManaged(i), ref field5.RefManaged(i), ref field6.RefManaged(i), ref field7.RefManaged(i), ref field8.RefManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, Ecs.FindRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSharedManaged(i), ref field1.RefSharedManaged(i), ref field2.RefSharedManaged(i), ref field3.RefSharedManaged(i), ref field4.RefSharedManaged(i), ref field5.RefSharedManaged(i), ref field6.RefSharedManaged(i), ref field7.RefSharedManaged(i), ref field8.RefSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, Ecs.FindRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSparseManaged(i), ref field1.RefSparseManaged(i), ref field2.RefSparseManaged(i), ref field3.RefSparseManaged(i), ref field4.RefSparseManaged(i), ref field5.RefSparseManaged(i), ref field6.RefSparseManaged(i), ref field7.RefSparseManaged(i), ref field8.RefSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, Ecs.FindRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSparseSharedManaged(i), ref field1.RefSparseSharedManaged(i), ref field2.RefSparseSharedManaged(i), ref field3.RefSparseSharedManaged(i), ref field4.RefSparseSharedManaged(i), ref field5.RefSparseSharedManaged(i), ref field6.RefSparseSharedManaged(i), ref field7.RefSparseSharedManaged(i), ref field8.RefSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 
     /// <summary>
@@ -48,25 +160,135 @@ public static Entity Find<T0, T1, T2, T3, T4, T5, T6, T7, T8>(Iter it, Ecs.FindE
     {
         int count = it.Handle->count; Ecs.Assert(it.Handle->count > 0, "No entities returned, use Iter() or Each() without the entity argument instead.");
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8);
+        IterationTechnique flags = it.GetIterationTechnique(9);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>())
         {
-            if (!callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref Managed.GetTypeRef<T0>(pointer0), ref Managed.GetTypeRef<T1>(pointer1), ref Managed.GetTypeRef<T2>(pointer2), ref Managed.GetTypeRef<T3>(pointer3), ref Managed.GetTypeRef<T4>(pointer4), ref Managed.GetTypeRef<T5>(pointer5), ref Managed.GetTypeRef<T6>(pointer6), ref Managed.GetTypeRef<T7>(pointer7), ref Managed.GetTypeRef<T8>(pointer8)))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefUnmanaged(i), ref field1.RefUnmanaged(i), ref field2.RefUnmanaged(i), ref field3.RefUnmanaged(i), ref field4.RefUnmanaged(i), ref field5.RefUnmanaged(i), ref field6.RefUnmanaged(i), ref field7.RefUnmanaged(i), ref field8.RefUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSharedUnmanaged(i), ref field1.RefSharedUnmanaged(i), ref field2.RefSharedUnmanaged(i), ref field3.RefSharedUnmanaged(i), ref field4.RefSharedUnmanaged(i), ref field5.RefSharedUnmanaged(i), ref field6.RefSharedUnmanaged(i), ref field7.RefSharedUnmanaged(i), ref field8.RefSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseUnmanaged(i), ref field1.RefSparseUnmanaged(i), ref field2.RefSparseUnmanaged(i), ref field3.RefSparseUnmanaged(i), ref field4.RefSparseUnmanaged(i), ref field5.RefSparseUnmanaged(i), ref field6.RefSparseUnmanaged(i), ref field7.RefSparseUnmanaged(i), ref field8.RefSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseSharedUnmanaged(i), ref field1.RefSparseSharedUnmanaged(i), ref field2.RefSparseSharedUnmanaged(i), ref field3.RefSparseSharedUnmanaged(i), ref field4.RefSparseSharedUnmanaged(i), ref field5.RefSparseSharedUnmanaged(i), ref field6.RefSparseSharedUnmanaged(i), ref field7.RefSparseSharedUnmanaged(i), ref field8.RefSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefManaged(i), ref field1.RefManaged(i), ref field2.RefManaged(i), ref field3.RefManaged(i), ref field4.RefManaged(i), ref field5.RefManaged(i), ref field6.RefManaged(i), ref field7.RefManaged(i), ref field8.RefManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSharedManaged(i), ref field1.RefSharedManaged(i), ref field2.RefSharedManaged(i), ref field3.RefSharedManaged(i), ref field4.RefSharedManaged(i), ref field5.RefSharedManaged(i), ref field6.RefSharedManaged(i), ref field7.RefSharedManaged(i), ref field8.RefSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseManaged(i), ref field1.RefSparseManaged(i), ref field2.RefSparseManaged(i), ref field3.RefSparseManaged(i), ref field4.RefSparseManaged(i), ref field5.RefSparseManaged(i), ref field6.RefSparseManaged(i), ref field7.RefSparseManaged(i), ref field8.RefSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseSharedManaged(i), ref field1.RefSparseSharedManaged(i), ref field2.RefSparseSharedManaged(i), ref field3.RefSparseSharedManaged(i), ref field4.RefSparseSharedManaged(i), ref field5.RefSparseSharedManaged(i), ref field6.RefSparseSharedManaged(i), ref field7.RefSparseSharedManaged(i), ref field8.RefSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 
     /// <summary>
@@ -79,25 +301,135 @@ public static Entity Find<T0, T1, T2, T3, T4, T5, T6, T7, T8>(Iter it, Ecs.FindI
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8);
+        IterationTechnique flags = it.GetIterationTechnique(9);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>())
         {
-            if (!callback(it, i, ref Managed.GetTypeRef<T0>(pointer0), ref Managed.GetTypeRef<T1>(pointer1), ref Managed.GetTypeRef<T2>(pointer2), ref Managed.GetTypeRef<T3>(pointer3), ref Managed.GetTypeRef<T4>(pointer4), ref Managed.GetTypeRef<T5>(pointer5), ref Managed.GetTypeRef<T6>(pointer6), ref Managed.GetTypeRef<T7>(pointer7), ref Managed.GetTypeRef<T8>(pointer8)))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, Ecs.FindIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefUnmanaged(i), ref field1.RefUnmanaged(i), ref field2.RefUnmanaged(i), ref field3.RefUnmanaged(i), ref field4.RefUnmanaged(i), ref field5.RefUnmanaged(i), ref field6.RefUnmanaged(i), ref field7.RefUnmanaged(i), ref field8.RefUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, Ecs.FindIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSharedUnmanaged(i), ref field1.RefSharedUnmanaged(i), ref field2.RefSharedUnmanaged(i), ref field3.RefSharedUnmanaged(i), ref field4.RefSharedUnmanaged(i), ref field5.RefSharedUnmanaged(i), ref field6.RefSharedUnmanaged(i), ref field7.RefSharedUnmanaged(i), ref field8.RefSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, Ecs.FindIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSparseUnmanaged(i), ref field1.RefSparseUnmanaged(i), ref field2.RefSparseUnmanaged(i), ref field3.RefSparseUnmanaged(i), ref field4.RefSparseUnmanaged(i), ref field5.RefSparseUnmanaged(i), ref field6.RefSparseUnmanaged(i), ref field7.RefSparseUnmanaged(i), ref field8.RefSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, Ecs.FindIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSparseSharedUnmanaged(i), ref field1.RefSparseSharedUnmanaged(i), ref field2.RefSparseSharedUnmanaged(i), ref field3.RefSparseSharedUnmanaged(i), ref field4.RefSparseSharedUnmanaged(i), ref field5.RefSparseSharedUnmanaged(i), ref field6.RefSparseSharedUnmanaged(i), ref field7.RefSparseSharedUnmanaged(i), ref field8.RefSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, Ecs.FindIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefManaged(i), ref field1.RefManaged(i), ref field2.RefManaged(i), ref field3.RefManaged(i), ref field4.RefManaged(i), ref field5.RefManaged(i), ref field6.RefManaged(i), ref field7.RefManaged(i), ref field8.RefManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, Ecs.FindIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSharedManaged(i), ref field1.RefSharedManaged(i), ref field2.RefSharedManaged(i), ref field3.RefSharedManaged(i), ref field4.RefSharedManaged(i), ref field5.RefSharedManaged(i), ref field6.RefSharedManaged(i), ref field7.RefSharedManaged(i), ref field8.RefSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, Ecs.FindIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSparseManaged(i), ref field1.RefSparseManaged(i), ref field2.RefSparseManaged(i), ref field3.RefSparseManaged(i), ref field4.RefSparseManaged(i), ref field5.RefSparseManaged(i), ref field6.RefSparseManaged(i), ref field7.RefSparseManaged(i), ref field8.RefSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, Ecs.FindIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSparseSharedManaged(i), ref field1.RefSparseSharedManaged(i), ref field2.RefSparseSharedManaged(i), ref field3.RefSparseSharedManaged(i), ref field4.RefSparseSharedManaged(i), ref field5.RefSparseSharedManaged(i), ref field6.RefSparseSharedManaged(i), ref field7.RefSparseSharedManaged(i), ref field8.RefSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 
     /// <summary>
@@ -110,25 +442,135 @@ public static Entity Find<T0, T1, T2, T3, T4, T5, T6, T7, T8>(Iter it, delegate*
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8);
+        IterationTechnique flags = it.GetIterationTechnique(9);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>())
         {
-            if (!callback(ref Managed.GetTypeRef<T0>(pointer0), ref Managed.GetTypeRef<T1>(pointer1), ref Managed.GetTypeRef<T2>(pointer2), ref Managed.GetTypeRef<T3>(pointer3), ref Managed.GetTypeRef<T4>(pointer4), ref Managed.GetTypeRef<T5>(pointer5), ref Managed.GetTypeRef<T6>(pointer6), ref Managed.GetTypeRef<T7>(pointer7), ref Managed.GetTypeRef<T8>(pointer8)))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefUnmanaged(i), ref field1.RefUnmanaged(i), ref field2.RefUnmanaged(i), ref field3.RefUnmanaged(i), ref field4.RefUnmanaged(i), ref field5.RefUnmanaged(i), ref field6.RefUnmanaged(i), ref field7.RefUnmanaged(i), ref field8.RefUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSharedUnmanaged(i), ref field1.RefSharedUnmanaged(i), ref field2.RefSharedUnmanaged(i), ref field3.RefSharedUnmanaged(i), ref field4.RefSharedUnmanaged(i), ref field5.RefSharedUnmanaged(i), ref field6.RefSharedUnmanaged(i), ref field7.RefSharedUnmanaged(i), ref field8.RefSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSparseUnmanaged(i), ref field1.RefSparseUnmanaged(i), ref field2.RefSparseUnmanaged(i), ref field3.RefSparseUnmanaged(i), ref field4.RefSparseUnmanaged(i), ref field5.RefSparseUnmanaged(i), ref field6.RefSparseUnmanaged(i), ref field7.RefSparseUnmanaged(i), ref field8.RefSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSparseSharedUnmanaged(i), ref field1.RefSparseSharedUnmanaged(i), ref field2.RefSparseSharedUnmanaged(i), ref field3.RefSparseSharedUnmanaged(i), ref field4.RefSparseSharedUnmanaged(i), ref field5.RefSparseSharedUnmanaged(i), ref field6.RefSparseSharedUnmanaged(i), ref field7.RefSparseSharedUnmanaged(i), ref field8.RefSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefManaged(i), ref field1.RefManaged(i), ref field2.RefManaged(i), ref field3.RefManaged(i), ref field4.RefManaged(i), ref field5.RefManaged(i), ref field6.RefManaged(i), ref field7.RefManaged(i), ref field8.RefManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSharedManaged(i), ref field1.RefSharedManaged(i), ref field2.RefSharedManaged(i), ref field3.RefSharedManaged(i), ref field4.RefSharedManaged(i), ref field5.RefSharedManaged(i), ref field6.RefSharedManaged(i), ref field7.RefSharedManaged(i), ref field8.RefSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSparseManaged(i), ref field1.RefSparseManaged(i), ref field2.RefSparseManaged(i), ref field3.RefSparseManaged(i), ref field4.RefSparseManaged(i), ref field5.RefSparseManaged(i), ref field6.RefSparseManaged(i), ref field7.RefSparseManaged(i), ref field8.RefSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(ref field0.RefSparseSharedManaged(i), ref field1.RefSparseSharedManaged(i), ref field2.RefSparseSharedManaged(i), ref field3.RefSparseSharedManaged(i), ref field4.RefSparseSharedManaged(i), ref field5.RefSparseSharedManaged(i), ref field6.RefSparseSharedManaged(i), ref field7.RefSparseSharedManaged(i), ref field8.RefSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 
     /// <summary>
@@ -141,25 +583,135 @@ public static Entity Find<T0, T1, T2, T3, T4, T5, T6, T7, T8>(Iter it, delegate*
     {
         int count = it.Handle->count; Ecs.Assert(it.Handle->count > 0, "No entities returned, use Iter() or Each() without the entity argument instead.");
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8);
+        IterationTechnique flags = it.GetIterationTechnique(9);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>())
         {
-            if (!callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref Managed.GetTypeRef<T0>(pointer0), ref Managed.GetTypeRef<T1>(pointer1), ref Managed.GetTypeRef<T2>(pointer2), ref Managed.GetTypeRef<T3>(pointer3), ref Managed.GetTypeRef<T4>(pointer4), ref Managed.GetTypeRef<T5>(pointer5), ref Managed.GetTypeRef<T6>(pointer6), ref Managed.GetTypeRef<T7>(pointer7), ref Managed.GetTypeRef<T8>(pointer8)))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefUnmanaged(i), ref field1.RefUnmanaged(i), ref field2.RefUnmanaged(i), ref field3.RefUnmanaged(i), ref field4.RefUnmanaged(i), ref field5.RefUnmanaged(i), ref field6.RefUnmanaged(i), ref field7.RefUnmanaged(i), ref field8.RefUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSharedUnmanaged(i), ref field1.RefSharedUnmanaged(i), ref field2.RefSharedUnmanaged(i), ref field3.RefSharedUnmanaged(i), ref field4.RefSharedUnmanaged(i), ref field5.RefSharedUnmanaged(i), ref field6.RefSharedUnmanaged(i), ref field7.RefSharedUnmanaged(i), ref field8.RefSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseUnmanaged(i), ref field1.RefSparseUnmanaged(i), ref field2.RefSparseUnmanaged(i), ref field3.RefSparseUnmanaged(i), ref field4.RefSparseUnmanaged(i), ref field5.RefSparseUnmanaged(i), ref field6.RefSparseUnmanaged(i), ref field7.RefSparseUnmanaged(i), ref field8.RefSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseSharedUnmanaged(i), ref field1.RefSparseSharedUnmanaged(i), ref field2.RefSparseSharedUnmanaged(i), ref field3.RefSparseSharedUnmanaged(i), ref field4.RefSparseSharedUnmanaged(i), ref field5.RefSparseSharedUnmanaged(i), ref field6.RefSparseSharedUnmanaged(i), ref field7.RefSparseSharedUnmanaged(i), ref field8.RefSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefManaged(i), ref field1.RefManaged(i), ref field2.RefManaged(i), ref field3.RefManaged(i), ref field4.RefManaged(i), ref field5.RefManaged(i), ref field6.RefManaged(i), ref field7.RefManaged(i), ref field8.RefManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSharedManaged(i), ref field1.RefSharedManaged(i), ref field2.RefSharedManaged(i), ref field3.RefSharedManaged(i), ref field4.RefSharedManaged(i), ref field5.RefSharedManaged(i), ref field6.RefSharedManaged(i), ref field7.RefSharedManaged(i), ref field8.RefSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseManaged(i), ref field1.RefSparseManaged(i), ref field2.RefSparseManaged(i), ref field3.RefSparseManaged(i), ref field4.RefSparseManaged(i), ref field5.RefSparseManaged(i), ref field6.RefSparseManaged(i), ref field7.RefSparseManaged(i), ref field8.RefSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), ref field0.RefSparseSharedManaged(i), ref field1.RefSparseSharedManaged(i), ref field2.RefSparseSharedManaged(i), ref field3.RefSparseSharedManaged(i), ref field4.RefSparseSharedManaged(i), ref field5.RefSparseSharedManaged(i), ref field6.RefSparseSharedManaged(i), ref field7.RefSparseSharedManaged(i), ref field8.RefSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 
     /// <summary>
@@ -172,25 +724,135 @@ public static Entity Find<T0, T1, T2, T3, T4, T5, T6, T7, T8>(Iter it, delegate*
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8);
+        IterationTechnique flags = it.GetIterationTechnique(9);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>())
         {
-            if (!callback(it, i, ref Managed.GetTypeRef<T0>(pointer0), ref Managed.GetTypeRef<T1>(pointer1), ref Managed.GetTypeRef<T2>(pointer2), ref Managed.GetTypeRef<T3>(pointer3), ref Managed.GetTypeRef<T4>(pointer4), ref Managed.GetTypeRef<T5>(pointer5), ref Managed.GetTypeRef<T6>(pointer6), ref Managed.GetTypeRef<T7>(pointer7), ref Managed.GetTypeRef<T8>(pointer8)))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefUnmanaged(i), ref field1.RefUnmanaged(i), ref field2.RefUnmanaged(i), ref field3.RefUnmanaged(i), ref field4.RefUnmanaged(i), ref field5.RefUnmanaged(i), ref field6.RefUnmanaged(i), ref field7.RefUnmanaged(i), ref field8.RefUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSharedUnmanaged(i), ref field1.RefSharedUnmanaged(i), ref field2.RefSharedUnmanaged(i), ref field3.RefSharedUnmanaged(i), ref field4.RefSharedUnmanaged(i), ref field5.RefSharedUnmanaged(i), ref field6.RefSharedUnmanaged(i), ref field7.RefSharedUnmanaged(i), ref field8.RefSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSparseUnmanaged(i), ref field1.RefSparseUnmanaged(i), ref field2.RefSparseUnmanaged(i), ref field3.RefSparseUnmanaged(i), ref field4.RefSparseUnmanaged(i), ref field5.RefSparseUnmanaged(i), ref field6.RefSparseUnmanaged(i), ref field7.RefSparseUnmanaged(i), ref field8.RefSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSparseSharedUnmanaged(i), ref field1.RefSparseSharedUnmanaged(i), ref field2.RefSparseSharedUnmanaged(i), ref field3.RefSparseSharedUnmanaged(i), ref field4.RefSparseSharedUnmanaged(i), ref field5.RefSparseSharedUnmanaged(i), ref field6.RefSparseSharedUnmanaged(i), ref field7.RefSparseSharedUnmanaged(i), ref field8.RefSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefManaged(i), ref field1.RefManaged(i), ref field2.RefManaged(i), ref field3.RefManaged(i), ref field4.RefManaged(i), ref field5.RefManaged(i), ref field6.RefManaged(i), ref field7.RefManaged(i), ref field8.RefManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSharedManaged(i), ref field1.RefSharedManaged(i), ref field2.RefSharedManaged(i), ref field3.RefSharedManaged(i), ref field4.RefSharedManaged(i), ref field5.RefSharedManaged(i), ref field6.RefSharedManaged(i), ref field7.RefSharedManaged(i), ref field8.RefSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSparseManaged(i), ref field1.RefSparseManaged(i), ref field2.RefSparseManaged(i), ref field3.RefSparseManaged(i), ref field4.RefSparseManaged(i), ref field5.RefSparseManaged(i), ref field6.RefSparseManaged(i), ref field7.RefSparseManaged(i), ref field8.RefSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, ref field0.RefSparseSharedManaged(i), ref field1.RefSparseSharedManaged(i), ref field2.RefSparseSharedManaged(i), ref field3.RefSparseSharedManaged(i), ref field4.RefSparseSharedManaged(i), ref field5.RefSparseSharedManaged(i), ref field6.RefSparseSharedManaged(i), ref field7.RefSparseSharedManaged(i), ref field8.RefSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 
     /// <summary>
@@ -203,25 +865,135 @@ public static Entity Find<T0, T1, T2, T3, T4, T5, T6, T7, T8>(Iter it, Ecs.FindP
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8);
+        IterationTechnique flags = it.GetIterationTechnique(9);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>())
         {
-            if (!callback((T0*)pointer0, (T1*)pointer1, (T2*)pointer2, (T3*)pointer3, (T4*)pointer4, (T5*)pointer5, (T6*)pointer6, (T7*)pointer7, (T8*)pointer8))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, Ecs.FindPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerUnmanaged(i), field1.PointerUnmanaged(i), field2.PointerUnmanaged(i), field3.PointerUnmanaged(i), field4.PointerUnmanaged(i), field5.PointerUnmanaged(i), field6.PointerUnmanaged(i), field7.PointerUnmanaged(i), field8.PointerUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, Ecs.FindPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSharedUnmanaged(i), field1.PointerSharedUnmanaged(i), field2.PointerSharedUnmanaged(i), field3.PointerSharedUnmanaged(i), field4.PointerSharedUnmanaged(i), field5.PointerSharedUnmanaged(i), field6.PointerSharedUnmanaged(i), field7.PointerSharedUnmanaged(i), field8.PointerSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, Ecs.FindPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSparseUnmanaged(i), field1.PointerSparseUnmanaged(i), field2.PointerSparseUnmanaged(i), field3.PointerSparseUnmanaged(i), field4.PointerSparseUnmanaged(i), field5.PointerSparseUnmanaged(i), field6.PointerSparseUnmanaged(i), field7.PointerSparseUnmanaged(i), field8.PointerSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, Ecs.FindPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSparseSharedUnmanaged(i), field1.PointerSparseSharedUnmanaged(i), field2.PointerSparseSharedUnmanaged(i), field3.PointerSparseSharedUnmanaged(i), field4.PointerSparseSharedUnmanaged(i), field5.PointerSparseSharedUnmanaged(i), field6.PointerSparseSharedUnmanaged(i), field7.PointerSparseSharedUnmanaged(i), field8.PointerSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, Ecs.FindPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerManaged(i), field1.PointerManaged(i), field2.PointerManaged(i), field3.PointerManaged(i), field4.PointerManaged(i), field5.PointerManaged(i), field6.PointerManaged(i), field7.PointerManaged(i), field8.PointerManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, Ecs.FindPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSharedManaged(i), field1.PointerSharedManaged(i), field2.PointerSharedManaged(i), field3.PointerSharedManaged(i), field4.PointerSharedManaged(i), field5.PointerSharedManaged(i), field6.PointerSharedManaged(i), field7.PointerSharedManaged(i), field8.PointerSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, Ecs.FindPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSparseManaged(i), field1.PointerSparseManaged(i), field2.PointerSparseManaged(i), field3.PointerSparseManaged(i), field4.PointerSparseManaged(i), field5.PointerSparseManaged(i), field6.PointerSparseManaged(i), field7.PointerSparseManaged(i), field8.PointerSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, Ecs.FindPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSparseSharedManaged(i), field1.PointerSparseSharedManaged(i), field2.PointerSparseSharedManaged(i), field3.PointerSparseSharedManaged(i), field4.PointerSparseSharedManaged(i), field5.PointerSparseSharedManaged(i), field6.PointerSparseSharedManaged(i), field7.PointerSparseSharedManaged(i), field8.PointerSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 
     /// <summary>
@@ -234,25 +1006,135 @@ public static Entity Find<T0, T1, T2, T3, T4, T5, T6, T7, T8>(Iter it, Ecs.FindE
     {
         int count = it.Handle->count; Ecs.Assert(it.Handle->count > 0, "No entities returned, use Iter() or Each() without the entity argument instead.");
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8);
+        IterationTechnique flags = it.GetIterationTechnique(9);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>())
         {
-            if (!callback(new Entity(it.Handle->world, it.Handle->entities[i]), (T0*)pointer0, (T1*)pointer1, (T2*)pointer2, (T3*)pointer3, (T4*)pointer4, (T5*)pointer5, (T6*)pointer6, (T7*)pointer7, (T8*)pointer8))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerUnmanaged(i), field1.PointerUnmanaged(i), field2.PointerUnmanaged(i), field3.PointerUnmanaged(i), field4.PointerUnmanaged(i), field5.PointerUnmanaged(i), field6.PointerUnmanaged(i), field7.PointerUnmanaged(i), field8.PointerUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSharedUnmanaged(i), field1.PointerSharedUnmanaged(i), field2.PointerSharedUnmanaged(i), field3.PointerSharedUnmanaged(i), field4.PointerSharedUnmanaged(i), field5.PointerSharedUnmanaged(i), field6.PointerSharedUnmanaged(i), field7.PointerSharedUnmanaged(i), field8.PointerSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseUnmanaged(i), field1.PointerSparseUnmanaged(i), field2.PointerSparseUnmanaged(i), field3.PointerSparseUnmanaged(i), field4.PointerSparseUnmanaged(i), field5.PointerSparseUnmanaged(i), field6.PointerSparseUnmanaged(i), field7.PointerSparseUnmanaged(i), field8.PointerSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseSharedUnmanaged(i), field1.PointerSparseSharedUnmanaged(i), field2.PointerSparseSharedUnmanaged(i), field3.PointerSparseSharedUnmanaged(i), field4.PointerSparseSharedUnmanaged(i), field5.PointerSparseSharedUnmanaged(i), field6.PointerSparseSharedUnmanaged(i), field7.PointerSparseSharedUnmanaged(i), field8.PointerSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerManaged(i), field1.PointerManaged(i), field2.PointerManaged(i), field3.PointerManaged(i), field4.PointerManaged(i), field5.PointerManaged(i), field6.PointerManaged(i), field7.PointerManaged(i), field8.PointerManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSharedManaged(i), field1.PointerSharedManaged(i), field2.PointerSharedManaged(i), field3.PointerSharedManaged(i), field4.PointerSharedManaged(i), field5.PointerSharedManaged(i), field6.PointerSharedManaged(i), field7.PointerSharedManaged(i), field8.PointerSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseManaged(i), field1.PointerSparseManaged(i), field2.PointerSparseManaged(i), field3.PointerSparseManaged(i), field4.PointerSparseManaged(i), field5.PointerSparseManaged(i), field6.PointerSparseManaged(i), field7.PointerSparseManaged(i), field8.PointerSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseSharedManaged(i), field1.PointerSparseSharedManaged(i), field2.PointerSparseSharedManaged(i), field3.PointerSparseSharedManaged(i), field4.PointerSparseSharedManaged(i), field5.PointerSparseSharedManaged(i), field6.PointerSparseSharedManaged(i), field7.PointerSparseSharedManaged(i), field8.PointerSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 
     /// <summary>
@@ -265,25 +1147,135 @@ public static Entity Find<T0, T1, T2, T3, T4, T5, T6, T7, T8>(Iter it, Ecs.FindI
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8);
+        IterationTechnique flags = it.GetIterationTechnique(9);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>())
         {
-            if (!callback(it, i, (T0*)pointer0, (T1*)pointer1, (T2*)pointer2, (T3*)pointer3, (T4*)pointer4, (T5*)pointer5, (T6*)pointer6, (T7*)pointer7, (T8*)pointer8))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerUnmanaged(i), field1.PointerUnmanaged(i), field2.PointerUnmanaged(i), field3.PointerUnmanaged(i), field4.PointerUnmanaged(i), field5.PointerUnmanaged(i), field6.PointerUnmanaged(i), field7.PointerUnmanaged(i), field8.PointerUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSharedUnmanaged(i), field1.PointerSharedUnmanaged(i), field2.PointerSharedUnmanaged(i), field3.PointerSharedUnmanaged(i), field4.PointerSharedUnmanaged(i), field5.PointerSharedUnmanaged(i), field6.PointerSharedUnmanaged(i), field7.PointerSharedUnmanaged(i), field8.PointerSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSparseUnmanaged(i), field1.PointerSparseUnmanaged(i), field2.PointerSparseUnmanaged(i), field3.PointerSparseUnmanaged(i), field4.PointerSparseUnmanaged(i), field5.PointerSparseUnmanaged(i), field6.PointerSparseUnmanaged(i), field7.PointerSparseUnmanaged(i), field8.PointerSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSparseSharedUnmanaged(i), field1.PointerSparseSharedUnmanaged(i), field2.PointerSparseSharedUnmanaged(i), field3.PointerSparseSharedUnmanaged(i), field4.PointerSparseSharedUnmanaged(i), field5.PointerSparseSharedUnmanaged(i), field6.PointerSparseSharedUnmanaged(i), field7.PointerSparseSharedUnmanaged(i), field8.PointerSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerManaged(i), field1.PointerManaged(i), field2.PointerManaged(i), field3.PointerManaged(i), field4.PointerManaged(i), field5.PointerManaged(i), field6.PointerManaged(i), field7.PointerManaged(i), field8.PointerManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSharedManaged(i), field1.PointerSharedManaged(i), field2.PointerSharedManaged(i), field3.PointerSharedManaged(i), field4.PointerSharedManaged(i), field5.PointerSharedManaged(i), field6.PointerSharedManaged(i), field7.PointerSharedManaged(i), field8.PointerSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSparseManaged(i), field1.PointerSparseManaged(i), field2.PointerSparseManaged(i), field3.PointerSparseManaged(i), field4.PointerSparseManaged(i), field5.PointerSparseManaged(i), field6.PointerSparseManaged(i), field7.PointerSparseManaged(i), field8.PointerSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSparseSharedManaged(i), field1.PointerSparseSharedManaged(i), field2.PointerSparseSharedManaged(i), field3.PointerSparseSharedManaged(i), field4.PointerSparseSharedManaged(i), field5.PointerSparseSharedManaged(i), field6.PointerSparseSharedManaged(i), field7.PointerSparseSharedManaged(i), field8.PointerSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 
     /// <summary>
@@ -296,25 +1288,135 @@ public static Entity Find<T0, T1, T2, T3, T4, T5, T6, T7, T8>(Iter it, delegate*
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8);
+        IterationTechnique flags = it.GetIterationTechnique(9);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>())
         {
-            if (!callback((T0*)pointer0, (T1*)pointer1, (T2*)pointer2, (T3*)pointer3, (T4*)pointer4, (T5*)pointer5, (T6*)pointer6, (T7*)pointer7, (T8*)pointer8))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerUnmanaged(i), field1.PointerUnmanaged(i), field2.PointerUnmanaged(i), field3.PointerUnmanaged(i), field4.PointerUnmanaged(i), field5.PointerUnmanaged(i), field6.PointerUnmanaged(i), field7.PointerUnmanaged(i), field8.PointerUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSharedUnmanaged(i), field1.PointerSharedUnmanaged(i), field2.PointerSharedUnmanaged(i), field3.PointerSharedUnmanaged(i), field4.PointerSharedUnmanaged(i), field5.PointerSharedUnmanaged(i), field6.PointerSharedUnmanaged(i), field7.PointerSharedUnmanaged(i), field8.PointerSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSparseUnmanaged(i), field1.PointerSparseUnmanaged(i), field2.PointerSparseUnmanaged(i), field3.PointerSparseUnmanaged(i), field4.PointerSparseUnmanaged(i), field5.PointerSparseUnmanaged(i), field6.PointerSparseUnmanaged(i), field7.PointerSparseUnmanaged(i), field8.PointerSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSparseSharedUnmanaged(i), field1.PointerSparseSharedUnmanaged(i), field2.PointerSparseSharedUnmanaged(i), field3.PointerSparseSharedUnmanaged(i), field4.PointerSparseSharedUnmanaged(i), field5.PointerSparseSharedUnmanaged(i), field6.PointerSparseSharedUnmanaged(i), field7.PointerSparseSharedUnmanaged(i), field8.PointerSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerManaged(i), field1.PointerManaged(i), field2.PointerManaged(i), field3.PointerManaged(i), field4.PointerManaged(i), field5.PointerManaged(i), field6.PointerManaged(i), field7.PointerManaged(i), field8.PointerManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSharedManaged(i), field1.PointerSharedManaged(i), field2.PointerSharedManaged(i), field3.PointerSharedManaged(i), field4.PointerSharedManaged(i), field5.PointerSharedManaged(i), field6.PointerSharedManaged(i), field7.PointerSharedManaged(i), field8.PointerSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSparseManaged(i), field1.PointerSparseManaged(i), field2.PointerSparseManaged(i), field3.PointerSparseManaged(i), field4.PointerSparseManaged(i), field5.PointerSparseManaged(i), field6.PointerSparseManaged(i), field7.PointerSparseManaged(i), field8.PointerSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(field0.PointerSparseSharedManaged(i), field1.PointerSparseSharedManaged(i), field2.PointerSparseSharedManaged(i), field3.PointerSparseSharedManaged(i), field4.PointerSparseSharedManaged(i), field5.PointerSparseSharedManaged(i), field6.PointerSparseSharedManaged(i), field7.PointerSparseSharedManaged(i), field8.PointerSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 
     /// <summary>
@@ -327,25 +1429,135 @@ public static Entity Find<T0, T1, T2, T3, T4, T5, T6, T7, T8>(Iter it, delegate*
     {
         int count = it.Handle->count; Ecs.Assert(it.Handle->count > 0, "No entities returned, use Iter() or Each() without the entity argument instead.");
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8);
+        IterationTechnique flags = it.GetIterationTechnique(9);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>())
         {
-            if (!callback(new Entity(it.Handle->world, it.Handle->entities[i]), (T0*)pointer0, (T1*)pointer1, (T2*)pointer2, (T3*)pointer3, (T4*)pointer4, (T5*)pointer5, (T6*)pointer6, (T7*)pointer7, (T8*)pointer8))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerUnmanaged(i), field1.PointerUnmanaged(i), field2.PointerUnmanaged(i), field3.PointerUnmanaged(i), field4.PointerUnmanaged(i), field5.PointerUnmanaged(i), field6.PointerUnmanaged(i), field7.PointerUnmanaged(i), field8.PointerUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSharedUnmanaged(i), field1.PointerSharedUnmanaged(i), field2.PointerSharedUnmanaged(i), field3.PointerSharedUnmanaged(i), field4.PointerSharedUnmanaged(i), field5.PointerSharedUnmanaged(i), field6.PointerSharedUnmanaged(i), field7.PointerSharedUnmanaged(i), field8.PointerSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseUnmanaged(i), field1.PointerSparseUnmanaged(i), field2.PointerSparseUnmanaged(i), field3.PointerSparseUnmanaged(i), field4.PointerSparseUnmanaged(i), field5.PointerSparseUnmanaged(i), field6.PointerSparseUnmanaged(i), field7.PointerSparseUnmanaged(i), field8.PointerSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseSharedUnmanaged(i), field1.PointerSparseSharedUnmanaged(i), field2.PointerSparseSharedUnmanaged(i), field3.PointerSparseSharedUnmanaged(i), field4.PointerSparseSharedUnmanaged(i), field5.PointerSparseSharedUnmanaged(i), field6.PointerSparseSharedUnmanaged(i), field7.PointerSparseSharedUnmanaged(i), field8.PointerSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerManaged(i), field1.PointerManaged(i), field2.PointerManaged(i), field3.PointerManaged(i), field4.PointerManaged(i), field5.PointerManaged(i), field6.PointerManaged(i), field7.PointerManaged(i), field8.PointerManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSharedManaged(i), field1.PointerSharedManaged(i), field2.PointerSharedManaged(i), field3.PointerSharedManaged(i), field4.PointerSharedManaged(i), field5.PointerSharedManaged(i), field6.PointerSharedManaged(i), field7.PointerSharedManaged(i), field8.PointerSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseManaged(i), field1.PointerSparseManaged(i), field2.PointerSparseManaged(i), field3.PointerSparseManaged(i), field4.PointerSparseManaged(i), field5.PointerSparseManaged(i), field6.PointerSparseManaged(i), field7.PointerSparseManaged(i), field8.PointerSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(new Entity(it.Handle->world, it.Handle->entities[i]), field0.PointerSparseSharedManaged(i), field1.PointerSparseSharedManaged(i), field2.PointerSparseSharedManaged(i), field3.PointerSparseSharedManaged(i), field4.PointerSparseSharedManaged(i), field5.PointerSparseSharedManaged(i), field6.PointerSparseSharedManaged(i), field7.PointerSparseSharedManaged(i), field8.PointerSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 
     /// <summary>
@@ -358,24 +1570,134 @@ public static Entity Find<T0, T1, T2, T3, T4, T5, T6, T7, T8>(Iter it, delegate*
     {
         int count = it.Handle->count == 0 && it.Handle->table == null ? 1 : it.Handle->count;
         
-        byte* pointer0 = (byte*)it.GetPointer<T0>(0); byte* pointer1 = (byte*)it.GetPointer<T1>(1); byte* pointer2 = (byte*)it.GetPointer<T2>(2); byte* pointer3 = (byte*)it.GetPointer<T3>(3); byte* pointer4 = (byte*)it.GetPointer<T4>(4); byte* pointer5 = (byte*)it.GetPointer<T5>(5); byte* pointer6 = (byte*)it.GetPointer<T6>(6); byte* pointer7 = (byte*)it.GetPointer<T7>(7); byte* pointer8 = (byte*)it.GetPointer<T8>(8);
-        int step0 = it.Step<T0>(0); int step1 = it.Step<T1>(1); int step2 = it.Step<T2>(2); int step3 = it.Step<T3>(3); int step4 = it.Step<T4>(4); int step5 = it.Step<T5>(5); int step6 = it.Step<T6>(6); int step7 = it.Step<T7>(7); int step8 = it.Step<T8>(8);
+        FieldData<T0> field0 = it.GetFieldData<T0>(0); FieldData<T1> field1 = it.GetFieldData<T1>(1); FieldData<T2> field2 = it.GetFieldData<T2>(2); FieldData<T3> field3 = it.GetFieldData<T3>(3); FieldData<T4> field4 = it.GetFieldData<T4>(4); FieldData<T5> field5 = it.GetFieldData<T5>(5); FieldData<T6> field6 = it.GetFieldData<T6>(6); FieldData<T7> field7 = it.GetFieldData<T7>(7); FieldData<T8> field8 = it.GetFieldData<T8>(8);
+        IterationTechnique flags = it.GetIterationTechnique(9);
             
         Ecs.TableLock(it);
         
         Entity result = default;
-            
-        for (int i = 0; i < count; i++, pointer0 = &pointer0[step0], pointer1 = &pointer1[step1], pointer2 = &pointer2[step2], pointer3 = &pointer3[step3], pointer4 = &pointer4[step4], pointer5 = &pointer5[step5], pointer6 = &pointer6[step6], pointer7 = &pointer7[step7], pointer8 = &pointer8[step8])
+        
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() || RuntimeHelpers.IsReferenceOrContainsReferences<T1>() || RuntimeHelpers.IsReferenceOrContainsReferences<T2>() || RuntimeHelpers.IsReferenceOrContainsReferences<T3>() || RuntimeHelpers.IsReferenceOrContainsReferences<T4>() || RuntimeHelpers.IsReferenceOrContainsReferences<T5>() || RuntimeHelpers.IsReferenceOrContainsReferences<T6>() || RuntimeHelpers.IsReferenceOrContainsReferences<T7>() || RuntimeHelpers.IsReferenceOrContainsReferences<T8>())
         {
-            if (!callback(it, i, (T0*)pointer0, (T1*)pointer1, (T2*)pointer2, (T3*)pointer3, (T4*)pointer4, (T5*)pointer5, (T6*)pointer6, (T7*)pointer7, (T8*)pointer8))
-                continue;
-                
-            result = new Entity(it.Handle->world, it.Handle->entities[i]);
-            break;
+            if (flags == IterationTechnique.None)
+                result = Managed(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedManaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
+        }
+        else
+        {
+           if (flags == IterationTechnique.None)
+                result = Unmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
+            else if (flags == IterationTechnique.Shared)
+                result = SharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
+            else if (flags == IterationTechnique.Sparse)
+                result = SparseUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
+            else if (flags == (IterationTechnique.Sparse | IterationTechnique.Shared))
+                result = SparseSharedUnmanaged(it, count, callback, ref field0, ref field1, ref field2, ref field3, ref field4, ref field5, ref field6, ref field7, ref field8);
         }
             
         Ecs.TableUnlock(it);
         
         return result;
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Unmanaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerUnmanaged(i), field1.PointerUnmanaged(i), field2.PointerUnmanaged(i), field3.PointerUnmanaged(i), field4.PointerUnmanaged(i), field5.PointerUnmanaged(i), field6.PointerUnmanaged(i), field7.PointerUnmanaged(i), field8.PointerUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedUnmanaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSharedUnmanaged(i), field1.PointerSharedUnmanaged(i), field2.PointerSharedUnmanaged(i), field3.PointerSharedUnmanaged(i), field4.PointerSharedUnmanaged(i), field5.PointerSharedUnmanaged(i), field6.PointerSharedUnmanaged(i), field7.PointerSharedUnmanaged(i), field8.PointerSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseUnmanaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSparseUnmanaged(i), field1.PointerSparseUnmanaged(i), field2.PointerSparseUnmanaged(i), field3.PointerSparseUnmanaged(i), field4.PointerSparseUnmanaged(i), field5.PointerSparseUnmanaged(i), field6.PointerSparseUnmanaged(i), field7.PointerSparseUnmanaged(i), field8.PointerSparseUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedUnmanaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSparseSharedUnmanaged(i), field1.PointerSparseSharedUnmanaged(i), field2.PointerSparseSharedUnmanaged(i), field3.PointerSparseSharedUnmanaged(i), field4.PointerSparseSharedUnmanaged(i), field5.PointerSparseSharedUnmanaged(i), field6.PointerSparseSharedUnmanaged(i), field7.PointerSparseSharedUnmanaged(i), field8.PointerSparseSharedUnmanaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity Managed(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerManaged(i), field1.PointerManaged(i), field2.PointerManaged(i), field3.PointerManaged(i), field4.PointerManaged(i), field5.PointerManaged(i), field6.PointerManaged(i), field7.PointerManaged(i), field8.PointerManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SharedManaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSharedManaged(i), field1.PointerSharedManaged(i), field2.PointerSharedManaged(i), field3.PointerSharedManaged(i), field4.PointerSharedManaged(i), field5.PointerSharedManaged(i), field6.PointerSharedManaged(i), field7.PointerSharedManaged(i), field8.PointerSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseManaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSparseManaged(i), field1.PointerSparseManaged(i), field2.PointerSparseManaged(i), field3.PointerSparseManaged(i), field4.PointerSparseManaged(i), field5.PointerSparseManaged(i), field6.PointerSparseManaged(i), field7.PointerSparseManaged(i), field8.PointerSparseManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static Entity SparseSharedManaged(Iter it, int count, delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, bool> callback, ref FieldData<T0> field0, ref FieldData<T1> field1, ref FieldData<T2> field2, ref FieldData<T3> field3, ref FieldData<T4> field4, ref FieldData<T5> field5, ref FieldData<T6> field6, ref FieldData<T7> field7, ref FieldData<T8> field8)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (callback(it, i, field0.PointerSparseSharedManaged(i), field1.PointerSparseSharedManaged(i), field2.PointerSparseSharedManaged(i), field3.PointerSparseSharedManaged(i), field4.PointerSparseSharedManaged(i), field5.PointerSparseSharedManaged(i), field6.PointerSparseSharedManaged(i), field7.PointerSparseSharedManaged(i), field8.PointerSparseSharedManaged(i)))
+                    return new Entity(it.Handle->world, it.Handle->entities[i]);
+            }
+                
+            return default;
+        }
     }
 }
\ No newline at end of file
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/IterIterable/IterIterable.IIterable/T1.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/IterIterable/IterIterable.IIterable/T1.g.cs
index f8222337..3ece1caa 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/IterIterable/IterIterable.IIterable/T1.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/IterIterable/IterIterable.IIterable/T1.g.cs
@@ -13,6 +13,7 @@ public unsafe partial struct IterIterable<T0>
     public void Run(Ecs.RunCallback callback)
     {
         TypeHelper<T0>.AssertReferenceTypes(true);
+        TypeHelper<T0>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Run(ref this, callback);
     }
 
@@ -23,6 +24,7 @@ public void Run(Ecs.RunCallback callback)
     public void Run(delegate*<Iter, void> callback)
     {
         TypeHelper<T0>.AssertReferenceTypes(true);
+        TypeHelper<T0>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Run(ref this, callback);
     }
 
@@ -33,6 +35,7 @@ public void Run(delegate*<Iter, void> callback)
     public void Iter(Ecs.IterFieldCallback<T0> callback)
     {
         TypeHelper<T0>.AssertReferenceTypes(true);
+        TypeHelper<T0>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -43,6 +46,7 @@ public void Iter(Ecs.IterFieldCallback<T0> callback)
     public void Iter(Ecs.IterSpanCallback<T0> callback)
     {
         TypeHelper<T0>.AssertReferenceTypes(false);
+        TypeHelper<T0>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -53,6 +57,7 @@ public void Iter(Ecs.IterSpanCallback<T0> callback)
     public void Iter(Ecs.IterPointerCallback<T0> callback)
     {
         TypeHelper<T0>.AssertReferenceTypes(false);
+        TypeHelper<T0>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -63,6 +68,7 @@ public void Iter(Ecs.IterPointerCallback<T0> callback)
     public void Iter(delegate*<Iter, Field<T0>, void> callback)
     {
         TypeHelper<T0>.AssertReferenceTypes(true);
+        TypeHelper<T0>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -73,6 +79,7 @@ public void Iter(delegate*<Iter, Field<T0>, void> callback)
     public void Iter(delegate*<Iter, Span<T0>, void> callback)
     {
         TypeHelper<T0>.AssertReferenceTypes(false);
+        TypeHelper<T0>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -83,6 +90,7 @@ public void Iter(delegate*<Iter, Span<T0>, void> callback)
     public void Iter(delegate*<Iter, T0*, void> callback)
     {
         TypeHelper<T0>.AssertReferenceTypes(false);
+        TypeHelper<T0>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -93,6 +101,7 @@ public void Iter(delegate*<Iter, T0*, void> callback)
     public void Each(Ecs.EachRefCallback<T0> callback)
     {
         TypeHelper<T0>.AssertReferenceTypes(true);
+        TypeHelper<T0>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -103,6 +112,7 @@ public void Each(Ecs.EachRefCallback<T0> callback)
     public void Each(Ecs.EachEntityRefCallback<T0> callback)
     {
         TypeHelper<T0>.AssertReferenceTypes(true);
+        TypeHelper<T0>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -113,6 +123,7 @@ public void Each(Ecs.EachEntityRefCallback<T0> callback)
     public void Each(Ecs.EachIterRefCallback<T0> callback)
     {
         TypeHelper<T0>.AssertReferenceTypes(true);
+        TypeHelper<T0>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -123,6 +134,7 @@ public void Each(Ecs.EachIterRefCallback<T0> callback)
     public void Each(delegate*<ref T0, void> callback)
     {
         TypeHelper<T0>.AssertReferenceTypes(true);
+        TypeHelper<T0>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -133,6 +145,7 @@ public void Each(delegate*<ref T0, void> callback)
     public void Each(delegate*<Entity, ref T0, void> callback)
     {
         TypeHelper<T0>.AssertReferenceTypes(true);
+        TypeHelper<T0>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -143,6 +156,7 @@ public void Each(delegate*<Entity, ref T0, void> callback)
     public void Each(delegate*<Iter, int, ref T0, void> callback)
     {
         TypeHelper<T0>.AssertReferenceTypes(true);
+        TypeHelper<T0>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -153,6 +167,7 @@ public void Each(delegate*<Iter, int, ref T0, void> callback)
     public void Each(Ecs.EachPointerCallback<T0> callback)
     {
         TypeHelper<T0>.AssertReferenceTypes(false);
+        TypeHelper<T0>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -163,6 +178,7 @@ public void Each(Ecs.EachPointerCallback<T0> callback)
     public void Each(Ecs.EachEntityPointerCallback<T0> callback)
     {
         TypeHelper<T0>.AssertReferenceTypes(false);
+        TypeHelper<T0>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -173,6 +189,7 @@ public void Each(Ecs.EachEntityPointerCallback<T0> callback)
     public void Each(Ecs.EachIterPointerCallback<T0> callback)
     {
         TypeHelper<T0>.AssertReferenceTypes(false);
+        TypeHelper<T0>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -183,6 +200,7 @@ public void Each(Ecs.EachIterPointerCallback<T0> callback)
     public void Each(delegate*<T0*, void> callback)
     {
         TypeHelper<T0>.AssertReferenceTypes(false);
+        TypeHelper<T0>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -193,6 +211,7 @@ public void Each(delegate*<T0*, void> callback)
     public void Each(delegate*<Entity, T0*, void> callback)
     {
         TypeHelper<T0>.AssertReferenceTypes(false);
+        TypeHelper<T0>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -203,6 +222,7 @@ public void Each(delegate*<Entity, T0*, void> callback)
     public void Each(delegate*<Iter, int, T0*, void> callback)
     {
         TypeHelper<T0>.AssertReferenceTypes(false);
+        TypeHelper<T0>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -213,6 +233,7 @@ public void Each(delegate*<Iter, int, T0*, void> callback)
     public Entity Find(Ecs.FindRefCallback<T0> callback)
     {
         TypeHelper<T0>.AssertReferenceTypes(true);
+        TypeHelper<T0>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -223,6 +244,7 @@ public Entity Find(Ecs.FindRefCallback<T0> callback)
     public Entity Find(Ecs.FindEntityRefCallback<T0> callback)
     {
         TypeHelper<T0>.AssertReferenceTypes(true);
+        TypeHelper<T0>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -233,6 +255,7 @@ public Entity Find(Ecs.FindEntityRefCallback<T0> callback)
     public Entity Find(Ecs.FindIterRefCallback<T0> callback)
     {
         TypeHelper<T0>.AssertReferenceTypes(true);
+        TypeHelper<T0>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -243,6 +266,7 @@ public Entity Find(Ecs.FindIterRefCallback<T0> callback)
     public Entity Find(delegate*<ref T0, bool> callback)
     {
         TypeHelper<T0>.AssertReferenceTypes(true);
+        TypeHelper<T0>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -253,6 +277,7 @@ public Entity Find(delegate*<ref T0, bool> callback)
     public Entity Find(delegate*<Entity, ref T0, bool> callback)
     {
         TypeHelper<T0>.AssertReferenceTypes(true);
+        TypeHelper<T0>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -263,6 +288,7 @@ public Entity Find(delegate*<Entity, ref T0, bool> callback)
     public Entity Find(delegate*<Iter, int, ref T0, bool> callback)
     {
         TypeHelper<T0>.AssertReferenceTypes(true);
+        TypeHelper<T0>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -273,6 +299,7 @@ public Entity Find(delegate*<Iter, int, ref T0, bool> callback)
     public Entity Find(Ecs.FindPointerCallback<T0> callback)
     {
         TypeHelper<T0>.AssertReferenceTypes(false);
+        TypeHelper<T0>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -283,6 +310,7 @@ public Entity Find(Ecs.FindPointerCallback<T0> callback)
     public Entity Find(Ecs.FindEntityPointerCallback<T0> callback)
     {
         TypeHelper<T0>.AssertReferenceTypes(false);
+        TypeHelper<T0>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -293,6 +321,7 @@ public Entity Find(Ecs.FindEntityPointerCallback<T0> callback)
     public Entity Find(Ecs.FindIterPointerCallback<T0> callback)
     {
         TypeHelper<T0>.AssertReferenceTypes(false);
+        TypeHelper<T0>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -303,6 +332,7 @@ public Entity Find(Ecs.FindIterPointerCallback<T0> callback)
     public Entity Find(delegate*<T0*, bool> callback)
     {
         TypeHelper<T0>.AssertReferenceTypes(false);
+        TypeHelper<T0>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -313,6 +343,7 @@ public Entity Find(delegate*<T0*, bool> callback)
     public Entity Find(delegate*<Entity, T0*, bool> callback)
     {
         TypeHelper<T0>.AssertReferenceTypes(false);
+        TypeHelper<T0>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -323,6 +354,7 @@ public Entity Find(delegate*<Entity, T0*, bool> callback)
     public Entity Find(delegate*<Iter, int, T0*, bool> callback)
     {
         TypeHelper<T0>.AssertReferenceTypes(false);
+        TypeHelper<T0>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 }
\ No newline at end of file
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/IterIterable/IterIterable.IIterable/T10.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/IterIterable/IterIterable.IIterable/T10.g.cs
index 88c58d69..b3c26321 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/IterIterable/IterIterable.IIterable/T10.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/IterIterable/IterIterable.IIterable/T10.g.cs
@@ -13,6 +13,7 @@ public unsafe partial struct IterIterable<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9
     public void Run(Ecs.RunCallback callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Run(ref this, callback);
     }
 
@@ -23,6 +24,7 @@ public void Run(Ecs.RunCallback callback)
     public void Run(delegate*<Iter, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Run(ref this, callback);
     }
 
@@ -33,6 +35,7 @@ public void Run(delegate*<Iter, void> callback)
     public void Iter(Ecs.IterFieldCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -43,6 +46,7 @@ public void Iter(Ecs.IterFieldCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> c
     public void Iter(Ecs.IterSpanCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -53,6 +57,7 @@ public void Iter(Ecs.IterSpanCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> ca
     public void Iter(Ecs.IterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -63,6 +68,7 @@ public void Iter(Ecs.IterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>
     public void Iter(delegate*<Iter, Field<T0>, Field<T1>, Field<T2>, Field<T3>, Field<T4>, Field<T5>, Field<T6>, Field<T7>, Field<T8>, Field<T9>, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -73,6 +79,7 @@ public void Iter(delegate*<Iter, Field<T0>, Field<T1>, Field<T2>, Field<T3>, Fie
     public void Iter(delegate*<Iter, Span<T0>, Span<T1>, Span<T2>, Span<T3>, Span<T4>, Span<T5>, Span<T6>, Span<T7>, Span<T8>, Span<T9>, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -83,6 +90,7 @@ public void Iter(delegate*<Iter, Span<T0>, Span<T1>, Span<T2>, Span<T3>, Span<T4
     public void Iter(delegate*<Iter, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -93,6 +101,7 @@ public void Iter(delegate*<Iter, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9
     public void Each(Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -103,6 +112,7 @@ public void Each(Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> cal
     public void Each(Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -113,6 +123,7 @@ public void Each(Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T
     public void Each(Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -123,6 +134,7 @@ public void Each(Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>
     public void Each(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -133,6 +145,7 @@ public void Each(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T
     public void Each(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -143,6 +156,7 @@ public void Each(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T
     public void Each(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -153,6 +167,7 @@ public void Each(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, re
     public void Each(Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -163,6 +178,7 @@ public void Each(Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>
     public void Each(Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -173,6 +189,7 @@ public void Each(Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T
     public void Each(Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -183,6 +200,7 @@ public void Each(Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8,
     public void Each(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -193,6 +211,7 @@ public void Each(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, voi
     public void Each(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -203,6 +222,7 @@ public void Each(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*,
     public void Each(delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -213,6 +233,7 @@ public void Each(delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8
     public Entity Find(Ecs.FindRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -223,6 +244,7 @@ public Entity Find(Ecs.FindRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> c
     public Entity Find(Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -233,6 +255,7 @@ public Entity Find(Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8,
     public Entity Find(Ecs.FindIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -243,6 +266,7 @@ public Entity Find(Ecs.FindIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T
     public Entity Find(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -253,6 +277,7 @@ public Entity Find(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref
     public Entity Find(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -263,6 +288,7 @@ public Entity Find(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref
     public Entity Find(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -273,6 +299,7 @@ public Entity Find(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4,
     public Entity Find(Ecs.FindPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -283,6 +310,7 @@ public Entity Find(Ecs.FindPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T
     public Entity Find(Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -293,6 +321,7 @@ public Entity Find(Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7,
     public Entity Find(Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -303,6 +332,7 @@ public Entity Find(Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T
     public Entity Find(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -313,6 +343,7 @@ public Entity Find(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, b
     public Entity Find(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -323,6 +354,7 @@ public Entity Find(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*
     public Entity Find(delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 }
\ No newline at end of file
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/IterIterable/IterIterable.IIterable/T11.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/IterIterable/IterIterable.IIterable/T11.g.cs
index 8e36aa60..e4078492 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/IterIterable/IterIterable.IIterable/T11.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/IterIterable/IterIterable.IIterable/T11.g.cs
@@ -13,6 +13,7 @@ public unsafe partial struct IterIterable<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9
     public void Run(Ecs.RunCallback callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Run(ref this, callback);
     }
 
@@ -23,6 +24,7 @@ public void Run(Ecs.RunCallback callback)
     public void Run(delegate*<Iter, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Run(ref this, callback);
     }
 
@@ -33,6 +35,7 @@ public void Run(delegate*<Iter, void> callback)
     public void Iter(Ecs.IterFieldCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -43,6 +46,7 @@ public void Iter(Ecs.IterFieldCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T
     public void Iter(Ecs.IterSpanCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -53,6 +57,7 @@ public void Iter(Ecs.IterSpanCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T1
     public void Iter(Ecs.IterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -63,6 +68,7 @@ public void Iter(Ecs.IterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9,
     public void Iter(delegate*<Iter, Field<T0>, Field<T1>, Field<T2>, Field<T3>, Field<T4>, Field<T5>, Field<T6>, Field<T7>, Field<T8>, Field<T9>, Field<T10>, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -73,6 +79,7 @@ public void Iter(delegate*<Iter, Field<T0>, Field<T1>, Field<T2>, Field<T3>, Fie
     public void Iter(delegate*<Iter, Span<T0>, Span<T1>, Span<T2>, Span<T3>, Span<T4>, Span<T5>, Span<T6>, Span<T7>, Span<T8>, Span<T9>, Span<T10>, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -83,6 +90,7 @@ public void Iter(delegate*<Iter, Span<T0>, Span<T1>, Span<T2>, Span<T3>, Span<T4
     public void Iter(delegate*<Iter, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -93,6 +101,7 @@ public void Iter(delegate*<Iter, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9
     public void Each(Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -103,6 +112,7 @@ public void Each(Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10
     public void Each(Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -113,6 +123,7 @@ public void Each(Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T
     public void Each(Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -123,6 +134,7 @@ public void Each(Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9,
     public void Each(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -133,6 +145,7 @@ public void Each(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T
     public void Each(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -143,6 +156,7 @@ public void Each(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T
     public void Each(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -153,6 +167,7 @@ public void Each(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, re
     public void Each(Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -163,6 +178,7 @@ public void Each(Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9,
     public void Each(Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -173,6 +189,7 @@ public void Each(Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T
     public void Each(Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -183,6 +200,7 @@ public void Each(Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8,
     public void Each(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -193,6 +211,7 @@ public void Each(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10
     public void Each(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -203,6 +222,7 @@ public void Each(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*,
     public void Each(delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -213,6 +233,7 @@ public void Each(delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8
     public Entity Find(Ecs.FindRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -223,6 +244,7 @@ public Entity Find(Ecs.FindRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T
     public Entity Find(Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -233,6 +255,7 @@ public Entity Find(Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8,
     public Entity Find(Ecs.FindIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -243,6 +266,7 @@ public Entity Find(Ecs.FindIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T
     public Entity Find(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -253,6 +277,7 @@ public Entity Find(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref
     public Entity Find(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -263,6 +288,7 @@ public Entity Find(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref
     public Entity Find(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -273,6 +299,7 @@ public Entity Find(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4,
     public Entity Find(Ecs.FindPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -283,6 +310,7 @@ public Entity Find(Ecs.FindPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T
     public Entity Find(Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -293,6 +321,7 @@ public Entity Find(Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7,
     public Entity Find(Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -303,6 +332,7 @@ public Entity Find(Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T
     public Entity Find(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -313,6 +343,7 @@ public Entity Find(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T
     public Entity Find(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -323,6 +354,7 @@ public Entity Find(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*
     public Entity Find(delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 }
\ No newline at end of file
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/IterIterable/IterIterable.IIterable/T12.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/IterIterable/IterIterable.IIterable/T12.g.cs
index 4e50e0e1..8d66503d 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/IterIterable/IterIterable.IIterable/T12.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/IterIterable/IterIterable.IIterable/T12.g.cs
@@ -13,6 +13,7 @@ public unsafe partial struct IterIterable<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9
     public void Run(Ecs.RunCallback callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Run(ref this, callback);
     }
 
@@ -23,6 +24,7 @@ public void Run(Ecs.RunCallback callback)
     public void Run(delegate*<Iter, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Run(ref this, callback);
     }
 
@@ -33,6 +35,7 @@ public void Run(delegate*<Iter, void> callback)
     public void Iter(Ecs.IterFieldCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -43,6 +46,7 @@ public void Iter(Ecs.IterFieldCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T
     public void Iter(Ecs.IterSpanCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -53,6 +57,7 @@ public void Iter(Ecs.IterSpanCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T1
     public void Iter(Ecs.IterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -63,6 +68,7 @@ public void Iter(Ecs.IterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9,
     public void Iter(delegate*<Iter, Field<T0>, Field<T1>, Field<T2>, Field<T3>, Field<T4>, Field<T5>, Field<T6>, Field<T7>, Field<T8>, Field<T9>, Field<T10>, Field<T11>, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -73,6 +79,7 @@ public void Iter(delegate*<Iter, Field<T0>, Field<T1>, Field<T2>, Field<T3>, Fie
     public void Iter(delegate*<Iter, Span<T0>, Span<T1>, Span<T2>, Span<T3>, Span<T4>, Span<T5>, Span<T6>, Span<T7>, Span<T8>, Span<T9>, Span<T10>, Span<T11>, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -83,6 +90,7 @@ public void Iter(delegate*<Iter, Span<T0>, Span<T1>, Span<T2>, Span<T3>, Span<T4
     public void Iter(delegate*<Iter, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -93,6 +101,7 @@ public void Iter(delegate*<Iter, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9
     public void Each(Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -103,6 +112,7 @@ public void Each(Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10
     public void Each(Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -113,6 +123,7 @@ public void Each(Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T
     public void Each(Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -123,6 +134,7 @@ public void Each(Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9,
     public void Each(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -133,6 +145,7 @@ public void Each(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T
     public void Each(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -143,6 +156,7 @@ public void Each(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T
     public void Each(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -153,6 +167,7 @@ public void Each(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, re
     public void Each(Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -163,6 +178,7 @@ public void Each(Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9,
     public void Each(Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -173,6 +189,7 @@ public void Each(Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T
     public void Each(Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -183,6 +200,7 @@ public void Each(Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8,
     public void Each(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -193,6 +211,7 @@ public void Each(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10
     public void Each(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -203,6 +222,7 @@ public void Each(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*,
     public void Each(delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -213,6 +233,7 @@ public void Each(delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8
     public Entity Find(Ecs.FindRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -223,6 +244,7 @@ public Entity Find(Ecs.FindRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T
     public Entity Find(Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -233,6 +255,7 @@ public Entity Find(Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8,
     public Entity Find(Ecs.FindIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -243,6 +266,7 @@ public Entity Find(Ecs.FindIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T
     public Entity Find(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -253,6 +277,7 @@ public Entity Find(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref
     public Entity Find(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -263,6 +288,7 @@ public Entity Find(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref
     public Entity Find(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -273,6 +299,7 @@ public Entity Find(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4,
     public Entity Find(Ecs.FindPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -283,6 +310,7 @@ public Entity Find(Ecs.FindPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T
     public Entity Find(Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -293,6 +321,7 @@ public Entity Find(Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7,
     public Entity Find(Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -303,6 +332,7 @@ public Entity Find(Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T
     public Entity Find(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -313,6 +343,7 @@ public Entity Find(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T
     public Entity Find(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -323,6 +354,7 @@ public Entity Find(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*
     public Entity Find(delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 }
\ No newline at end of file
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/IterIterable/IterIterable.IIterable/T13.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/IterIterable/IterIterable.IIterable/T13.g.cs
index 498d0c57..a1660c24 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/IterIterable/IterIterable.IIterable/T13.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/IterIterable/IterIterable.IIterable/T13.g.cs
@@ -13,6 +13,7 @@ public unsafe partial struct IterIterable<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9
     public void Run(Ecs.RunCallback callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Run(ref this, callback);
     }
 
@@ -23,6 +24,7 @@ public void Run(Ecs.RunCallback callback)
     public void Run(delegate*<Iter, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Run(ref this, callback);
     }
 
@@ -33,6 +35,7 @@ public void Run(delegate*<Iter, void> callback)
     public void Iter(Ecs.IterFieldCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -43,6 +46,7 @@ public void Iter(Ecs.IterFieldCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T
     public void Iter(Ecs.IterSpanCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -53,6 +57,7 @@ public void Iter(Ecs.IterSpanCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T1
     public void Iter(Ecs.IterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -63,6 +68,7 @@ public void Iter(Ecs.IterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9,
     public void Iter(delegate*<Iter, Field<T0>, Field<T1>, Field<T2>, Field<T3>, Field<T4>, Field<T5>, Field<T6>, Field<T7>, Field<T8>, Field<T9>, Field<T10>, Field<T11>, Field<T12>, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -73,6 +79,7 @@ public void Iter(delegate*<Iter, Field<T0>, Field<T1>, Field<T2>, Field<T3>, Fie
     public void Iter(delegate*<Iter, Span<T0>, Span<T1>, Span<T2>, Span<T3>, Span<T4>, Span<T5>, Span<T6>, Span<T7>, Span<T8>, Span<T9>, Span<T10>, Span<T11>, Span<T12>, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -83,6 +90,7 @@ public void Iter(delegate*<Iter, Span<T0>, Span<T1>, Span<T2>, Span<T3>, Span<T4
     public void Iter(delegate*<Iter, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -93,6 +101,7 @@ public void Iter(delegate*<Iter, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9
     public void Each(Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -103,6 +112,7 @@ public void Each(Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10
     public void Each(Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -113,6 +123,7 @@ public void Each(Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T
     public void Each(Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -123,6 +134,7 @@ public void Each(Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9,
     public void Each(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -133,6 +145,7 @@ public void Each(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T
     public void Each(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -143,6 +156,7 @@ public void Each(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T
     public void Each(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -153,6 +167,7 @@ public void Each(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, re
     public void Each(Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -163,6 +178,7 @@ public void Each(Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9,
     public void Each(Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -173,6 +189,7 @@ public void Each(Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T
     public void Each(Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -183,6 +200,7 @@ public void Each(Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8,
     public void Each(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -193,6 +211,7 @@ public void Each(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10
     public void Each(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -203,6 +222,7 @@ public void Each(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*,
     public void Each(delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -213,6 +233,7 @@ public void Each(delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8
     public Entity Find(Ecs.FindRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -223,6 +244,7 @@ public Entity Find(Ecs.FindRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T
     public Entity Find(Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -233,6 +255,7 @@ public Entity Find(Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8,
     public Entity Find(Ecs.FindIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -243,6 +266,7 @@ public Entity Find(Ecs.FindIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T
     public Entity Find(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -253,6 +277,7 @@ public Entity Find(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref
     public Entity Find(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -263,6 +288,7 @@ public Entity Find(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref
     public Entity Find(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -273,6 +299,7 @@ public Entity Find(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4,
     public Entity Find(Ecs.FindPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -283,6 +310,7 @@ public Entity Find(Ecs.FindPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T
     public Entity Find(Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -293,6 +321,7 @@ public Entity Find(Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7,
     public Entity Find(Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -303,6 +332,7 @@ public Entity Find(Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T
     public Entity Find(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -313,6 +343,7 @@ public Entity Find(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T
     public Entity Find(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -323,6 +354,7 @@ public Entity Find(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*
     public Entity Find(delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 }
\ No newline at end of file
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/IterIterable/IterIterable.IIterable/T14.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/IterIterable/IterIterable.IIterable/T14.g.cs
index 8f87bdfc..1b56ba6c 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/IterIterable/IterIterable.IIterable/T14.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/IterIterable/IterIterable.IIterable/T14.g.cs
@@ -13,6 +13,7 @@ public unsafe partial struct IterIterable<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9
     public void Run(Ecs.RunCallback callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Run(ref this, callback);
     }
 
@@ -23,6 +24,7 @@ public void Run(Ecs.RunCallback callback)
     public void Run(delegate*<Iter, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Run(ref this, callback);
     }
 
@@ -33,6 +35,7 @@ public void Run(delegate*<Iter, void> callback)
     public void Iter(Ecs.IterFieldCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -43,6 +46,7 @@ public void Iter(Ecs.IterFieldCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T
     public void Iter(Ecs.IterSpanCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -53,6 +57,7 @@ public void Iter(Ecs.IterSpanCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T1
     public void Iter(Ecs.IterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -63,6 +68,7 @@ public void Iter(Ecs.IterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9,
     public void Iter(delegate*<Iter, Field<T0>, Field<T1>, Field<T2>, Field<T3>, Field<T4>, Field<T5>, Field<T6>, Field<T7>, Field<T8>, Field<T9>, Field<T10>, Field<T11>, Field<T12>, Field<T13>, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -73,6 +79,7 @@ public void Iter(delegate*<Iter, Field<T0>, Field<T1>, Field<T2>, Field<T3>, Fie
     public void Iter(delegate*<Iter, Span<T0>, Span<T1>, Span<T2>, Span<T3>, Span<T4>, Span<T5>, Span<T6>, Span<T7>, Span<T8>, Span<T9>, Span<T10>, Span<T11>, Span<T12>, Span<T13>, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -83,6 +90,7 @@ public void Iter(delegate*<Iter, Span<T0>, Span<T1>, Span<T2>, Span<T3>, Span<T4
     public void Iter(delegate*<Iter, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -93,6 +101,7 @@ public void Iter(delegate*<Iter, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9
     public void Each(Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -103,6 +112,7 @@ public void Each(Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10
     public void Each(Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -113,6 +123,7 @@ public void Each(Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T
     public void Each(Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -123,6 +134,7 @@ public void Each(Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9,
     public void Each(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -133,6 +145,7 @@ public void Each(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T
     public void Each(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -143,6 +156,7 @@ public void Each(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T
     public void Each(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -153,6 +167,7 @@ public void Each(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, re
     public void Each(Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -163,6 +178,7 @@ public void Each(Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9,
     public void Each(Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -173,6 +189,7 @@ public void Each(Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T
     public void Each(Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -183,6 +200,7 @@ public void Each(Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8,
     public void Each(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -193,6 +211,7 @@ public void Each(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10
     public void Each(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -203,6 +222,7 @@ public void Each(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*,
     public void Each(delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -213,6 +233,7 @@ public void Each(delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8
     public Entity Find(Ecs.FindRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -223,6 +244,7 @@ public Entity Find(Ecs.FindRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T
     public Entity Find(Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -233,6 +255,7 @@ public Entity Find(Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8,
     public Entity Find(Ecs.FindIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -243,6 +266,7 @@ public Entity Find(Ecs.FindIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T
     public Entity Find(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -253,6 +277,7 @@ public Entity Find(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref
     public Entity Find(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -263,6 +288,7 @@ public Entity Find(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref
     public Entity Find(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -273,6 +299,7 @@ public Entity Find(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4,
     public Entity Find(Ecs.FindPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -283,6 +310,7 @@ public Entity Find(Ecs.FindPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T
     public Entity Find(Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -293,6 +321,7 @@ public Entity Find(Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7,
     public Entity Find(Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -303,6 +332,7 @@ public Entity Find(Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T
     public Entity Find(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -313,6 +343,7 @@ public Entity Find(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T
     public Entity Find(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -323,6 +354,7 @@ public Entity Find(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*
     public Entity Find(delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 }
\ No newline at end of file
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/IterIterable/IterIterable.IIterable/T15.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/IterIterable/IterIterable.IIterable/T15.g.cs
index 4fd8ddd3..146ea919 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/IterIterable/IterIterable.IIterable/T15.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/IterIterable/IterIterable.IIterable/T15.g.cs
@@ -13,6 +13,7 @@ public unsafe partial struct IterIterable<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9
     public void Run(Ecs.RunCallback callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Run(ref this, callback);
     }
 
@@ -23,6 +24,7 @@ public void Run(Ecs.RunCallback callback)
     public void Run(delegate*<Iter, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Run(ref this, callback);
     }
 
@@ -33,6 +35,7 @@ public void Run(delegate*<Iter, void> callback)
     public void Iter(Ecs.IterFieldCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -43,6 +46,7 @@ public void Iter(Ecs.IterFieldCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T
     public void Iter(Ecs.IterSpanCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -53,6 +57,7 @@ public void Iter(Ecs.IterSpanCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T1
     public void Iter(Ecs.IterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -63,6 +68,7 @@ public void Iter(Ecs.IterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9,
     public void Iter(delegate*<Iter, Field<T0>, Field<T1>, Field<T2>, Field<T3>, Field<T4>, Field<T5>, Field<T6>, Field<T7>, Field<T8>, Field<T9>, Field<T10>, Field<T11>, Field<T12>, Field<T13>, Field<T14>, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -73,6 +79,7 @@ public void Iter(delegate*<Iter, Field<T0>, Field<T1>, Field<T2>, Field<T3>, Fie
     public void Iter(delegate*<Iter, Span<T0>, Span<T1>, Span<T2>, Span<T3>, Span<T4>, Span<T5>, Span<T6>, Span<T7>, Span<T8>, Span<T9>, Span<T10>, Span<T11>, Span<T12>, Span<T13>, Span<T14>, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -83,6 +90,7 @@ public void Iter(delegate*<Iter, Span<T0>, Span<T1>, Span<T2>, Span<T3>, Span<T4
     public void Iter(delegate*<Iter, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, T14*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -93,6 +101,7 @@ public void Iter(delegate*<Iter, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9
     public void Each(Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -103,6 +112,7 @@ public void Each(Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10
     public void Each(Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -113,6 +123,7 @@ public void Each(Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T
     public void Each(Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -123,6 +134,7 @@ public void Each(Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9,
     public void Each(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, ref T14, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -133,6 +145,7 @@ public void Each(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T
     public void Each(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, ref T14, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -143,6 +156,7 @@ public void Each(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T
     public void Each(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, ref T14, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -153,6 +167,7 @@ public void Each(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, re
     public void Each(Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -163,6 +178,7 @@ public void Each(Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9,
     public void Each(Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -173,6 +189,7 @@ public void Each(Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T
     public void Each(Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -183,6 +200,7 @@ public void Each(Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8,
     public void Each(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, T14*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -193,6 +211,7 @@ public void Each(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10
     public void Each(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, T14*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -203,6 +222,7 @@ public void Each(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*,
     public void Each(delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, T14*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -213,6 +233,7 @@ public void Each(delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8
     public Entity Find(Ecs.FindRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -223,6 +244,7 @@ public Entity Find(Ecs.FindRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T
     public Entity Find(Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -233,6 +255,7 @@ public Entity Find(Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8,
     public Entity Find(Ecs.FindIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -243,6 +266,7 @@ public Entity Find(Ecs.FindIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T
     public Entity Find(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, ref T14, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -253,6 +277,7 @@ public Entity Find(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref
     public Entity Find(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, ref T14, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -263,6 +288,7 @@ public Entity Find(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref
     public Entity Find(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, ref T14, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -273,6 +299,7 @@ public Entity Find(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4,
     public Entity Find(Ecs.FindPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -283,6 +310,7 @@ public Entity Find(Ecs.FindPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T
     public Entity Find(Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -293,6 +321,7 @@ public Entity Find(Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7,
     public Entity Find(Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -303,6 +332,7 @@ public Entity Find(Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T
     public Entity Find(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, T14*, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -313,6 +343,7 @@ public Entity Find(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T
     public Entity Find(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, T14*, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -323,6 +354,7 @@ public Entity Find(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*
     public Entity Find(delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, T14*, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 }
\ No newline at end of file
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/IterIterable/IterIterable.IIterable/T16.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/IterIterable/IterIterable.IIterable/T16.g.cs
index 8cb7ed2f..02f0d952 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/IterIterable/IterIterable.IIterable/T16.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/IterIterable/IterIterable.IIterable/T16.g.cs
@@ -13,6 +13,7 @@ public unsafe partial struct IterIterable<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9
     public void Run(Ecs.RunCallback callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Run(ref this, callback);
     }
 
@@ -23,6 +24,7 @@ public void Run(Ecs.RunCallback callback)
     public void Run(delegate*<Iter, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Run(ref this, callback);
     }
 
@@ -33,6 +35,7 @@ public void Run(delegate*<Iter, void> callback)
     public void Iter(Ecs.IterFieldCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -43,6 +46,7 @@ public void Iter(Ecs.IterFieldCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T
     public void Iter(Ecs.IterSpanCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -53,6 +57,7 @@ public void Iter(Ecs.IterSpanCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T1
     public void Iter(Ecs.IterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -63,6 +68,7 @@ public void Iter(Ecs.IterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9,
     public void Iter(delegate*<Iter, Field<T0>, Field<T1>, Field<T2>, Field<T3>, Field<T4>, Field<T5>, Field<T6>, Field<T7>, Field<T8>, Field<T9>, Field<T10>, Field<T11>, Field<T12>, Field<T13>, Field<T14>, Field<T15>, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -73,6 +79,7 @@ public void Iter(delegate*<Iter, Field<T0>, Field<T1>, Field<T2>, Field<T3>, Fie
     public void Iter(delegate*<Iter, Span<T0>, Span<T1>, Span<T2>, Span<T3>, Span<T4>, Span<T5>, Span<T6>, Span<T7>, Span<T8>, Span<T9>, Span<T10>, Span<T11>, Span<T12>, Span<T13>, Span<T14>, Span<T15>, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -83,6 +90,7 @@ public void Iter(delegate*<Iter, Span<T0>, Span<T1>, Span<T2>, Span<T3>, Span<T4
     public void Iter(delegate*<Iter, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, T14*, T15*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -93,6 +101,7 @@ public void Iter(delegate*<Iter, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9
     public void Each(Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -103,6 +112,7 @@ public void Each(Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10
     public void Each(Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -113,6 +123,7 @@ public void Each(Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T
     public void Each(Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -123,6 +134,7 @@ public void Each(Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9,
     public void Each(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, ref T14, ref T15, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -133,6 +145,7 @@ public void Each(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T
     public void Each(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, ref T14, ref T15, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -143,6 +156,7 @@ public void Each(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T
     public void Each(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, ref T14, ref T15, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -153,6 +167,7 @@ public void Each(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, re
     public void Each(Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -163,6 +178,7 @@ public void Each(Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9,
     public void Each(Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -173,6 +189,7 @@ public void Each(Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T
     public void Each(Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -183,6 +200,7 @@ public void Each(Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8,
     public void Each(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, T14*, T15*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -193,6 +211,7 @@ public void Each(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10
     public void Each(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, T14*, T15*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -203,6 +222,7 @@ public void Each(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*,
     public void Each(delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, T14*, T15*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -213,6 +233,7 @@ public void Each(delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8
     public Entity Find(Ecs.FindRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -223,6 +244,7 @@ public Entity Find(Ecs.FindRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T
     public Entity Find(Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -233,6 +255,7 @@ public Entity Find(Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8,
     public Entity Find(Ecs.FindIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -243,6 +266,7 @@ public Entity Find(Ecs.FindIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T
     public Entity Find(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, ref T14, ref T15, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -253,6 +277,7 @@ public Entity Find(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref
     public Entity Find(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, ref T14, ref T15, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -263,6 +288,7 @@ public Entity Find(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref
     public Entity Find(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, ref T14, ref T15, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -273,6 +299,7 @@ public Entity Find(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4,
     public Entity Find(Ecs.FindPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -283,6 +310,7 @@ public Entity Find(Ecs.FindPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T
     public Entity Find(Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -293,6 +321,7 @@ public Entity Find(Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7,
     public Entity Find(Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -303,6 +332,7 @@ public Entity Find(Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T
     public Entity Find(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, T14*, T15*, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -313,6 +343,7 @@ public Entity Find(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T
     public Entity Find(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, T14*, T15*, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -323,6 +354,7 @@ public Entity Find(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*
     public Entity Find(delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, T14*, T15*, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 }
\ No newline at end of file
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/IterIterable/IterIterable.IIterable/T2.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/IterIterable/IterIterable.IIterable/T2.g.cs
index 51b6b4a8..8e1d8110 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/IterIterable/IterIterable.IIterable/T2.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/IterIterable/IterIterable.IIterable/T2.g.cs
@@ -13,6 +13,7 @@ public unsafe partial struct IterIterable<T0, T1>
     public void Run(Ecs.RunCallback callback)
     {
         TypeHelper<T0, T1>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Run(ref this, callback);
     }
 
@@ -23,6 +24,7 @@ public void Run(Ecs.RunCallback callback)
     public void Run(delegate*<Iter, void> callback)
     {
         TypeHelper<T0, T1>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Run(ref this, callback);
     }
 
@@ -33,6 +35,7 @@ public void Run(delegate*<Iter, void> callback)
     public void Iter(Ecs.IterFieldCallback<T0, T1> callback)
     {
         TypeHelper<T0, T1>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -43,6 +46,7 @@ public void Iter(Ecs.IterFieldCallback<T0, T1> callback)
     public void Iter(Ecs.IterSpanCallback<T0, T1> callback)
     {
         TypeHelper<T0, T1>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -53,6 +57,7 @@ public void Iter(Ecs.IterSpanCallback<T0, T1> callback)
     public void Iter(Ecs.IterPointerCallback<T0, T1> callback)
     {
         TypeHelper<T0, T1>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -63,6 +68,7 @@ public void Iter(Ecs.IterPointerCallback<T0, T1> callback)
     public void Iter(delegate*<Iter, Field<T0>, Field<T1>, void> callback)
     {
         TypeHelper<T0, T1>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -73,6 +79,7 @@ public void Iter(delegate*<Iter, Field<T0>, Field<T1>, void> callback)
     public void Iter(delegate*<Iter, Span<T0>, Span<T1>, void> callback)
     {
         TypeHelper<T0, T1>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -83,6 +90,7 @@ public void Iter(delegate*<Iter, Span<T0>, Span<T1>, void> callback)
     public void Iter(delegate*<Iter, T0*, T1*, void> callback)
     {
         TypeHelper<T0, T1>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -93,6 +101,7 @@ public void Iter(delegate*<Iter, T0*, T1*, void> callback)
     public void Each(Ecs.EachRefCallback<T0, T1> callback)
     {
         TypeHelper<T0, T1>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -103,6 +112,7 @@ public void Each(Ecs.EachRefCallback<T0, T1> callback)
     public void Each(Ecs.EachEntityRefCallback<T0, T1> callback)
     {
         TypeHelper<T0, T1>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -113,6 +123,7 @@ public void Each(Ecs.EachEntityRefCallback<T0, T1> callback)
     public void Each(Ecs.EachIterRefCallback<T0, T1> callback)
     {
         TypeHelper<T0, T1>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -123,6 +134,7 @@ public void Each(Ecs.EachIterRefCallback<T0, T1> callback)
     public void Each(delegate*<ref T0, ref T1, void> callback)
     {
         TypeHelper<T0, T1>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -133,6 +145,7 @@ public void Each(delegate*<ref T0, ref T1, void> callback)
     public void Each(delegate*<Entity, ref T0, ref T1, void> callback)
     {
         TypeHelper<T0, T1>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -143,6 +156,7 @@ public void Each(delegate*<Entity, ref T0, ref T1, void> callback)
     public void Each(delegate*<Iter, int, ref T0, ref T1, void> callback)
     {
         TypeHelper<T0, T1>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -153,6 +167,7 @@ public void Each(delegate*<Iter, int, ref T0, ref T1, void> callback)
     public void Each(Ecs.EachPointerCallback<T0, T1> callback)
     {
         TypeHelper<T0, T1>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -163,6 +178,7 @@ public void Each(Ecs.EachPointerCallback<T0, T1> callback)
     public void Each(Ecs.EachEntityPointerCallback<T0, T1> callback)
     {
         TypeHelper<T0, T1>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -173,6 +189,7 @@ public void Each(Ecs.EachEntityPointerCallback<T0, T1> callback)
     public void Each(Ecs.EachIterPointerCallback<T0, T1> callback)
     {
         TypeHelper<T0, T1>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -183,6 +200,7 @@ public void Each(Ecs.EachIterPointerCallback<T0, T1> callback)
     public void Each(delegate*<T0*, T1*, void> callback)
     {
         TypeHelper<T0, T1>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -193,6 +211,7 @@ public void Each(delegate*<T0*, T1*, void> callback)
     public void Each(delegate*<Entity, T0*, T1*, void> callback)
     {
         TypeHelper<T0, T1>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -203,6 +222,7 @@ public void Each(delegate*<Entity, T0*, T1*, void> callback)
     public void Each(delegate*<Iter, int, T0*, T1*, void> callback)
     {
         TypeHelper<T0, T1>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -213,6 +233,7 @@ public void Each(delegate*<Iter, int, T0*, T1*, void> callback)
     public Entity Find(Ecs.FindRefCallback<T0, T1> callback)
     {
         TypeHelper<T0, T1>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -223,6 +244,7 @@ public Entity Find(Ecs.FindRefCallback<T0, T1> callback)
     public Entity Find(Ecs.FindEntityRefCallback<T0, T1> callback)
     {
         TypeHelper<T0, T1>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -233,6 +255,7 @@ public Entity Find(Ecs.FindEntityRefCallback<T0, T1> callback)
     public Entity Find(Ecs.FindIterRefCallback<T0, T1> callback)
     {
         TypeHelper<T0, T1>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -243,6 +266,7 @@ public Entity Find(Ecs.FindIterRefCallback<T0, T1> callback)
     public Entity Find(delegate*<ref T0, ref T1, bool> callback)
     {
         TypeHelper<T0, T1>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -253,6 +277,7 @@ public Entity Find(delegate*<ref T0, ref T1, bool> callback)
     public Entity Find(delegate*<Entity, ref T0, ref T1, bool> callback)
     {
         TypeHelper<T0, T1>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -263,6 +288,7 @@ public Entity Find(delegate*<Entity, ref T0, ref T1, bool> callback)
     public Entity Find(delegate*<Iter, int, ref T0, ref T1, bool> callback)
     {
         TypeHelper<T0, T1>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -273,6 +299,7 @@ public Entity Find(delegate*<Iter, int, ref T0, ref T1, bool> callback)
     public Entity Find(Ecs.FindPointerCallback<T0, T1> callback)
     {
         TypeHelper<T0, T1>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -283,6 +310,7 @@ public Entity Find(Ecs.FindPointerCallback<T0, T1> callback)
     public Entity Find(Ecs.FindEntityPointerCallback<T0, T1> callback)
     {
         TypeHelper<T0, T1>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -293,6 +321,7 @@ public Entity Find(Ecs.FindEntityPointerCallback<T0, T1> callback)
     public Entity Find(Ecs.FindIterPointerCallback<T0, T1> callback)
     {
         TypeHelper<T0, T1>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -303,6 +332,7 @@ public Entity Find(Ecs.FindIterPointerCallback<T0, T1> callback)
     public Entity Find(delegate*<T0*, T1*, bool> callback)
     {
         TypeHelper<T0, T1>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -313,6 +343,7 @@ public Entity Find(delegate*<T0*, T1*, bool> callback)
     public Entity Find(delegate*<Entity, T0*, T1*, bool> callback)
     {
         TypeHelper<T0, T1>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -323,6 +354,7 @@ public Entity Find(delegate*<Entity, T0*, T1*, bool> callback)
     public Entity Find(delegate*<Iter, int, T0*, T1*, bool> callback)
     {
         TypeHelper<T0, T1>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 }
\ No newline at end of file
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/IterIterable/IterIterable.IIterable/T3.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/IterIterable/IterIterable.IIterable/T3.g.cs
index 5e2757f3..2e5d2b52 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/IterIterable/IterIterable.IIterable/T3.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/IterIterable/IterIterable.IIterable/T3.g.cs
@@ -13,6 +13,7 @@ public unsafe partial struct IterIterable<T0, T1, T2>
     public void Run(Ecs.RunCallback callback)
     {
         TypeHelper<T0, T1, T2>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Run(ref this, callback);
     }
 
@@ -23,6 +24,7 @@ public void Run(Ecs.RunCallback callback)
     public void Run(delegate*<Iter, void> callback)
     {
         TypeHelper<T0, T1, T2>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Run(ref this, callback);
     }
 
@@ -33,6 +35,7 @@ public void Run(delegate*<Iter, void> callback)
     public void Iter(Ecs.IterFieldCallback<T0, T1, T2> callback)
     {
         TypeHelper<T0, T1, T2>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -43,6 +46,7 @@ public void Iter(Ecs.IterFieldCallback<T0, T1, T2> callback)
     public void Iter(Ecs.IterSpanCallback<T0, T1, T2> callback)
     {
         TypeHelper<T0, T1, T2>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -53,6 +57,7 @@ public void Iter(Ecs.IterSpanCallback<T0, T1, T2> callback)
     public void Iter(Ecs.IterPointerCallback<T0, T1, T2> callback)
     {
         TypeHelper<T0, T1, T2>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -63,6 +68,7 @@ public void Iter(Ecs.IterPointerCallback<T0, T1, T2> callback)
     public void Iter(delegate*<Iter, Field<T0>, Field<T1>, Field<T2>, void> callback)
     {
         TypeHelper<T0, T1, T2>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -73,6 +79,7 @@ public void Iter(delegate*<Iter, Field<T0>, Field<T1>, Field<T2>, void> callback
     public void Iter(delegate*<Iter, Span<T0>, Span<T1>, Span<T2>, void> callback)
     {
         TypeHelper<T0, T1, T2>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -83,6 +90,7 @@ public void Iter(delegate*<Iter, Span<T0>, Span<T1>, Span<T2>, void> callback)
     public void Iter(delegate*<Iter, T0*, T1*, T2*, void> callback)
     {
         TypeHelper<T0, T1, T2>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -93,6 +101,7 @@ public void Iter(delegate*<Iter, T0*, T1*, T2*, void> callback)
     public void Each(Ecs.EachRefCallback<T0, T1, T2> callback)
     {
         TypeHelper<T0, T1, T2>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -103,6 +112,7 @@ public void Each(Ecs.EachRefCallback<T0, T1, T2> callback)
     public void Each(Ecs.EachEntityRefCallback<T0, T1, T2> callback)
     {
         TypeHelper<T0, T1, T2>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -113,6 +123,7 @@ public void Each(Ecs.EachEntityRefCallback<T0, T1, T2> callback)
     public void Each(Ecs.EachIterRefCallback<T0, T1, T2> callback)
     {
         TypeHelper<T0, T1, T2>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -123,6 +134,7 @@ public void Each(Ecs.EachIterRefCallback<T0, T1, T2> callback)
     public void Each(delegate*<ref T0, ref T1, ref T2, void> callback)
     {
         TypeHelper<T0, T1, T2>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -133,6 +145,7 @@ public void Each(delegate*<ref T0, ref T1, ref T2, void> callback)
     public void Each(delegate*<Entity, ref T0, ref T1, ref T2, void> callback)
     {
         TypeHelper<T0, T1, T2>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -143,6 +156,7 @@ public void Each(delegate*<Entity, ref T0, ref T1, ref T2, void> callback)
     public void Each(delegate*<Iter, int, ref T0, ref T1, ref T2, void> callback)
     {
         TypeHelper<T0, T1, T2>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -153,6 +167,7 @@ public void Each(delegate*<Iter, int, ref T0, ref T1, ref T2, void> callback)
     public void Each(Ecs.EachPointerCallback<T0, T1, T2> callback)
     {
         TypeHelper<T0, T1, T2>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -163,6 +178,7 @@ public void Each(Ecs.EachPointerCallback<T0, T1, T2> callback)
     public void Each(Ecs.EachEntityPointerCallback<T0, T1, T2> callback)
     {
         TypeHelper<T0, T1, T2>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -173,6 +189,7 @@ public void Each(Ecs.EachEntityPointerCallback<T0, T1, T2> callback)
     public void Each(Ecs.EachIterPointerCallback<T0, T1, T2> callback)
     {
         TypeHelper<T0, T1, T2>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -183,6 +200,7 @@ public void Each(Ecs.EachIterPointerCallback<T0, T1, T2> callback)
     public void Each(delegate*<T0*, T1*, T2*, void> callback)
     {
         TypeHelper<T0, T1, T2>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -193,6 +211,7 @@ public void Each(delegate*<T0*, T1*, T2*, void> callback)
     public void Each(delegate*<Entity, T0*, T1*, T2*, void> callback)
     {
         TypeHelper<T0, T1, T2>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -203,6 +222,7 @@ public void Each(delegate*<Entity, T0*, T1*, T2*, void> callback)
     public void Each(delegate*<Iter, int, T0*, T1*, T2*, void> callback)
     {
         TypeHelper<T0, T1, T2>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -213,6 +233,7 @@ public void Each(delegate*<Iter, int, T0*, T1*, T2*, void> callback)
     public Entity Find(Ecs.FindRefCallback<T0, T1, T2> callback)
     {
         TypeHelper<T0, T1, T2>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -223,6 +244,7 @@ public Entity Find(Ecs.FindRefCallback<T0, T1, T2> callback)
     public Entity Find(Ecs.FindEntityRefCallback<T0, T1, T2> callback)
     {
         TypeHelper<T0, T1, T2>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -233,6 +255,7 @@ public Entity Find(Ecs.FindEntityRefCallback<T0, T1, T2> callback)
     public Entity Find(Ecs.FindIterRefCallback<T0, T1, T2> callback)
     {
         TypeHelper<T0, T1, T2>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -243,6 +266,7 @@ public Entity Find(Ecs.FindIterRefCallback<T0, T1, T2> callback)
     public Entity Find(delegate*<ref T0, ref T1, ref T2, bool> callback)
     {
         TypeHelper<T0, T1, T2>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -253,6 +277,7 @@ public Entity Find(delegate*<ref T0, ref T1, ref T2, bool> callback)
     public Entity Find(delegate*<Entity, ref T0, ref T1, ref T2, bool> callback)
     {
         TypeHelper<T0, T1, T2>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -263,6 +288,7 @@ public Entity Find(delegate*<Entity, ref T0, ref T1, ref T2, bool> callback)
     public Entity Find(delegate*<Iter, int, ref T0, ref T1, ref T2, bool> callback)
     {
         TypeHelper<T0, T1, T2>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -273,6 +299,7 @@ public Entity Find(delegate*<Iter, int, ref T0, ref T1, ref T2, bool> callback)
     public Entity Find(Ecs.FindPointerCallback<T0, T1, T2> callback)
     {
         TypeHelper<T0, T1, T2>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -283,6 +310,7 @@ public Entity Find(Ecs.FindPointerCallback<T0, T1, T2> callback)
     public Entity Find(Ecs.FindEntityPointerCallback<T0, T1, T2> callback)
     {
         TypeHelper<T0, T1, T2>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -293,6 +321,7 @@ public Entity Find(Ecs.FindEntityPointerCallback<T0, T1, T2> callback)
     public Entity Find(Ecs.FindIterPointerCallback<T0, T1, T2> callback)
     {
         TypeHelper<T0, T1, T2>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -303,6 +332,7 @@ public Entity Find(Ecs.FindIterPointerCallback<T0, T1, T2> callback)
     public Entity Find(delegate*<T0*, T1*, T2*, bool> callback)
     {
         TypeHelper<T0, T1, T2>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -313,6 +343,7 @@ public Entity Find(delegate*<T0*, T1*, T2*, bool> callback)
     public Entity Find(delegate*<Entity, T0*, T1*, T2*, bool> callback)
     {
         TypeHelper<T0, T1, T2>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -323,6 +354,7 @@ public Entity Find(delegate*<Entity, T0*, T1*, T2*, bool> callback)
     public Entity Find(delegate*<Iter, int, T0*, T1*, T2*, bool> callback)
     {
         TypeHelper<T0, T1, T2>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 }
\ No newline at end of file
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/IterIterable/IterIterable.IIterable/T4.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/IterIterable/IterIterable.IIterable/T4.g.cs
index b48668d1..0f0cc9bd 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/IterIterable/IterIterable.IIterable/T4.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/IterIterable/IterIterable.IIterable/T4.g.cs
@@ -13,6 +13,7 @@ public unsafe partial struct IterIterable<T0, T1, T2, T3>
     public void Run(Ecs.RunCallback callback)
     {
         TypeHelper<T0, T1, T2, T3>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Run(ref this, callback);
     }
 
@@ -23,6 +24,7 @@ public void Run(Ecs.RunCallback callback)
     public void Run(delegate*<Iter, void> callback)
     {
         TypeHelper<T0, T1, T2, T3>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Run(ref this, callback);
     }
 
@@ -33,6 +35,7 @@ public void Run(delegate*<Iter, void> callback)
     public void Iter(Ecs.IterFieldCallback<T0, T1, T2, T3> callback)
     {
         TypeHelper<T0, T1, T2, T3>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -43,6 +46,7 @@ public void Iter(Ecs.IterFieldCallback<T0, T1, T2, T3> callback)
     public void Iter(Ecs.IterSpanCallback<T0, T1, T2, T3> callback)
     {
         TypeHelper<T0, T1, T2, T3>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -53,6 +57,7 @@ public void Iter(Ecs.IterSpanCallback<T0, T1, T2, T3> callback)
     public void Iter(Ecs.IterPointerCallback<T0, T1, T2, T3> callback)
     {
         TypeHelper<T0, T1, T2, T3>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -63,6 +68,7 @@ public void Iter(Ecs.IterPointerCallback<T0, T1, T2, T3> callback)
     public void Iter(delegate*<Iter, Field<T0>, Field<T1>, Field<T2>, Field<T3>, void> callback)
     {
         TypeHelper<T0, T1, T2, T3>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -73,6 +79,7 @@ public void Iter(delegate*<Iter, Field<T0>, Field<T1>, Field<T2>, Field<T3>, voi
     public void Iter(delegate*<Iter, Span<T0>, Span<T1>, Span<T2>, Span<T3>, void> callback)
     {
         TypeHelper<T0, T1, T2, T3>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -83,6 +90,7 @@ public void Iter(delegate*<Iter, Span<T0>, Span<T1>, Span<T2>, Span<T3>, void> c
     public void Iter(delegate*<Iter, T0*, T1*, T2*, T3*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -93,6 +101,7 @@ public void Iter(delegate*<Iter, T0*, T1*, T2*, T3*, void> callback)
     public void Each(Ecs.EachRefCallback<T0, T1, T2, T3> callback)
     {
         TypeHelper<T0, T1, T2, T3>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -103,6 +112,7 @@ public void Each(Ecs.EachRefCallback<T0, T1, T2, T3> callback)
     public void Each(Ecs.EachEntityRefCallback<T0, T1, T2, T3> callback)
     {
         TypeHelper<T0, T1, T2, T3>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -113,6 +123,7 @@ public void Each(Ecs.EachEntityRefCallback<T0, T1, T2, T3> callback)
     public void Each(Ecs.EachIterRefCallback<T0, T1, T2, T3> callback)
     {
         TypeHelper<T0, T1, T2, T3>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -123,6 +134,7 @@ public void Each(Ecs.EachIterRefCallback<T0, T1, T2, T3> callback)
     public void Each(delegate*<ref T0, ref T1, ref T2, ref T3, void> callback)
     {
         TypeHelper<T0, T1, T2, T3>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -133,6 +145,7 @@ public void Each(delegate*<ref T0, ref T1, ref T2, ref T3, void> callback)
     public void Each(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, void> callback)
     {
         TypeHelper<T0, T1, T2, T3>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -143,6 +156,7 @@ public void Each(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, void> callbac
     public void Each(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, void> callback)
     {
         TypeHelper<T0, T1, T2, T3>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -153,6 +167,7 @@ public void Each(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, void> call
     public void Each(Ecs.EachPointerCallback<T0, T1, T2, T3> callback)
     {
         TypeHelper<T0, T1, T2, T3>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -163,6 +178,7 @@ public void Each(Ecs.EachPointerCallback<T0, T1, T2, T3> callback)
     public void Each(Ecs.EachEntityPointerCallback<T0, T1, T2, T3> callback)
     {
         TypeHelper<T0, T1, T2, T3>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -173,6 +189,7 @@ public void Each(Ecs.EachEntityPointerCallback<T0, T1, T2, T3> callback)
     public void Each(Ecs.EachIterPointerCallback<T0, T1, T2, T3> callback)
     {
         TypeHelper<T0, T1, T2, T3>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -183,6 +200,7 @@ public void Each(Ecs.EachIterPointerCallback<T0, T1, T2, T3> callback)
     public void Each(delegate*<T0*, T1*, T2*, T3*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -193,6 +211,7 @@ public void Each(delegate*<T0*, T1*, T2*, T3*, void> callback)
     public void Each(delegate*<Entity, T0*, T1*, T2*, T3*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -203,6 +222,7 @@ public void Each(delegate*<Entity, T0*, T1*, T2*, T3*, void> callback)
     public void Each(delegate*<Iter, int, T0*, T1*, T2*, T3*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -213,6 +233,7 @@ public void Each(delegate*<Iter, int, T0*, T1*, T2*, T3*, void> callback)
     public Entity Find(Ecs.FindRefCallback<T0, T1, T2, T3> callback)
     {
         TypeHelper<T0, T1, T2, T3>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -223,6 +244,7 @@ public Entity Find(Ecs.FindRefCallback<T0, T1, T2, T3> callback)
     public Entity Find(Ecs.FindEntityRefCallback<T0, T1, T2, T3> callback)
     {
         TypeHelper<T0, T1, T2, T3>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -233,6 +255,7 @@ public Entity Find(Ecs.FindEntityRefCallback<T0, T1, T2, T3> callback)
     public Entity Find(Ecs.FindIterRefCallback<T0, T1, T2, T3> callback)
     {
         TypeHelper<T0, T1, T2, T3>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -243,6 +266,7 @@ public Entity Find(Ecs.FindIterRefCallback<T0, T1, T2, T3> callback)
     public Entity Find(delegate*<ref T0, ref T1, ref T2, ref T3, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -253,6 +277,7 @@ public Entity Find(delegate*<ref T0, ref T1, ref T2, ref T3, bool> callback)
     public Entity Find(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -263,6 +288,7 @@ public Entity Find(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, bool> callb
     public Entity Find(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -273,6 +299,7 @@ public Entity Find(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, bool> ca
     public Entity Find(Ecs.FindPointerCallback<T0, T1, T2, T3> callback)
     {
         TypeHelper<T0, T1, T2, T3>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -283,6 +310,7 @@ public Entity Find(Ecs.FindPointerCallback<T0, T1, T2, T3> callback)
     public Entity Find(Ecs.FindEntityPointerCallback<T0, T1, T2, T3> callback)
     {
         TypeHelper<T0, T1, T2, T3>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -293,6 +321,7 @@ public Entity Find(Ecs.FindEntityPointerCallback<T0, T1, T2, T3> callback)
     public Entity Find(Ecs.FindIterPointerCallback<T0, T1, T2, T3> callback)
     {
         TypeHelper<T0, T1, T2, T3>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -303,6 +332,7 @@ public Entity Find(Ecs.FindIterPointerCallback<T0, T1, T2, T3> callback)
     public Entity Find(delegate*<T0*, T1*, T2*, T3*, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -313,6 +343,7 @@ public Entity Find(delegate*<T0*, T1*, T2*, T3*, bool> callback)
     public Entity Find(delegate*<Entity, T0*, T1*, T2*, T3*, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -323,6 +354,7 @@ public Entity Find(delegate*<Entity, T0*, T1*, T2*, T3*, bool> callback)
     public Entity Find(delegate*<Iter, int, T0*, T1*, T2*, T3*, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 }
\ No newline at end of file
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/IterIterable/IterIterable.IIterable/T5.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/IterIterable/IterIterable.IIterable/T5.g.cs
index 716873dd..cbb6cbdb 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/IterIterable/IterIterable.IIterable/T5.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/IterIterable/IterIterable.IIterable/T5.g.cs
@@ -13,6 +13,7 @@ public unsafe partial struct IterIterable<T0, T1, T2, T3, T4>
     public void Run(Ecs.RunCallback callback)
     {
         TypeHelper<T0, T1, T2, T3, T4>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Run(ref this, callback);
     }
 
@@ -23,6 +24,7 @@ public void Run(Ecs.RunCallback callback)
     public void Run(delegate*<Iter, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Run(ref this, callback);
     }
 
@@ -33,6 +35,7 @@ public void Run(delegate*<Iter, void> callback)
     public void Iter(Ecs.IterFieldCallback<T0, T1, T2, T3, T4> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -43,6 +46,7 @@ public void Iter(Ecs.IterFieldCallback<T0, T1, T2, T3, T4> callback)
     public void Iter(Ecs.IterSpanCallback<T0, T1, T2, T3, T4> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -53,6 +57,7 @@ public void Iter(Ecs.IterSpanCallback<T0, T1, T2, T3, T4> callback)
     public void Iter(Ecs.IterPointerCallback<T0, T1, T2, T3, T4> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -63,6 +68,7 @@ public void Iter(Ecs.IterPointerCallback<T0, T1, T2, T3, T4> callback)
     public void Iter(delegate*<Iter, Field<T0>, Field<T1>, Field<T2>, Field<T3>, Field<T4>, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -73,6 +79,7 @@ public void Iter(delegate*<Iter, Field<T0>, Field<T1>, Field<T2>, Field<T3>, Fie
     public void Iter(delegate*<Iter, Span<T0>, Span<T1>, Span<T2>, Span<T3>, Span<T4>, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -83,6 +90,7 @@ public void Iter(delegate*<Iter, Span<T0>, Span<T1>, Span<T2>, Span<T3>, Span<T4
     public void Iter(delegate*<Iter, T0*, T1*, T2*, T3*, T4*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -93,6 +101,7 @@ public void Iter(delegate*<Iter, T0*, T1*, T2*, T3*, T4*, void> callback)
     public void Each(Ecs.EachRefCallback<T0, T1, T2, T3, T4> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -103,6 +112,7 @@ public void Each(Ecs.EachRefCallback<T0, T1, T2, T3, T4> callback)
     public void Each(Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -113,6 +123,7 @@ public void Each(Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4> callback)
     public void Each(Ecs.EachIterRefCallback<T0, T1, T2, T3, T4> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -123,6 +134,7 @@ public void Each(Ecs.EachIterRefCallback<T0, T1, T2, T3, T4> callback)
     public void Each(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -133,6 +145,7 @@ public void Each(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, void> callbac
     public void Each(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -143,6 +156,7 @@ public void Each(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, void>
     public void Each(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -153,6 +167,7 @@ public void Each(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, vo
     public void Each(Ecs.EachPointerCallback<T0, T1, T2, T3, T4> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -163,6 +178,7 @@ public void Each(Ecs.EachPointerCallback<T0, T1, T2, T3, T4> callback)
     public void Each(Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -173,6 +189,7 @@ public void Each(Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4> callback)
     public void Each(Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -183,6 +200,7 @@ public void Each(Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4> callback)
     public void Each(delegate*<T0*, T1*, T2*, T3*, T4*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -193,6 +211,7 @@ public void Each(delegate*<T0*, T1*, T2*, T3*, T4*, void> callback)
     public void Each(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -203,6 +222,7 @@ public void Each(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, void> callback)
     public void Each(delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -213,6 +233,7 @@ public void Each(delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, void> callback)
     public Entity Find(Ecs.FindRefCallback<T0, T1, T2, T3, T4> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -223,6 +244,7 @@ public Entity Find(Ecs.FindRefCallback<T0, T1, T2, T3, T4> callback)
     public Entity Find(Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -233,6 +255,7 @@ public Entity Find(Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4> callback)
     public Entity Find(Ecs.FindIterRefCallback<T0, T1, T2, T3, T4> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -243,6 +266,7 @@ public Entity Find(Ecs.FindIterRefCallback<T0, T1, T2, T3, T4> callback)
     public Entity Find(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -253,6 +277,7 @@ public Entity Find(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, bool> callb
     public Entity Find(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -263,6 +288,7 @@ public Entity Find(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, boo
     public Entity Find(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -273,6 +299,7 @@ public Entity Find(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4,
     public Entity Find(Ecs.FindPointerCallback<T0, T1, T2, T3, T4> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -283,6 +310,7 @@ public Entity Find(Ecs.FindPointerCallback<T0, T1, T2, T3, T4> callback)
     public Entity Find(Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -293,6 +321,7 @@ public Entity Find(Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4> callback)
     public Entity Find(Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -303,6 +332,7 @@ public Entity Find(Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4> callback)
     public Entity Find(delegate*<T0*, T1*, T2*, T3*, T4*, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -313,6 +343,7 @@ public Entity Find(delegate*<T0*, T1*, T2*, T3*, T4*, bool> callback)
     public Entity Find(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -323,6 +354,7 @@ public Entity Find(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, bool> callback)
     public Entity Find(delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 }
\ No newline at end of file
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/IterIterable/IterIterable.IIterable/T6.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/IterIterable/IterIterable.IIterable/T6.g.cs
index 9f44aaa7..b191e362 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/IterIterable/IterIterable.IIterable/T6.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/IterIterable/IterIterable.IIterable/T6.g.cs
@@ -13,6 +13,7 @@ public unsafe partial struct IterIterable<T0, T1, T2, T3, T4, T5>
     public void Run(Ecs.RunCallback callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Run(ref this, callback);
     }
 
@@ -23,6 +24,7 @@ public void Run(Ecs.RunCallback callback)
     public void Run(delegate*<Iter, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Run(ref this, callback);
     }
 
@@ -33,6 +35,7 @@ public void Run(delegate*<Iter, void> callback)
     public void Iter(Ecs.IterFieldCallback<T0, T1, T2, T3, T4, T5> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -43,6 +46,7 @@ public void Iter(Ecs.IterFieldCallback<T0, T1, T2, T3, T4, T5> callback)
     public void Iter(Ecs.IterSpanCallback<T0, T1, T2, T3, T4, T5> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -53,6 +57,7 @@ public void Iter(Ecs.IterSpanCallback<T0, T1, T2, T3, T4, T5> callback)
     public void Iter(Ecs.IterPointerCallback<T0, T1, T2, T3, T4, T5> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -63,6 +68,7 @@ public void Iter(Ecs.IterPointerCallback<T0, T1, T2, T3, T4, T5> callback)
     public void Iter(delegate*<Iter, Field<T0>, Field<T1>, Field<T2>, Field<T3>, Field<T4>, Field<T5>, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -73,6 +79,7 @@ public void Iter(delegate*<Iter, Field<T0>, Field<T1>, Field<T2>, Field<T3>, Fie
     public void Iter(delegate*<Iter, Span<T0>, Span<T1>, Span<T2>, Span<T3>, Span<T4>, Span<T5>, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -83,6 +90,7 @@ public void Iter(delegate*<Iter, Span<T0>, Span<T1>, Span<T2>, Span<T3>, Span<T4
     public void Iter(delegate*<Iter, T0*, T1*, T2*, T3*, T4*, T5*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -93,6 +101,7 @@ public void Iter(delegate*<Iter, T0*, T1*, T2*, T3*, T4*, T5*, void> callback)
     public void Each(Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -103,6 +112,7 @@ public void Each(Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5> callback)
     public void Each(Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -113,6 +123,7 @@ public void Each(Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5> callback)
     public void Each(Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -123,6 +134,7 @@ public void Each(Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5> callback)
     public void Each(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -133,6 +145,7 @@ public void Each(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, void>
     public void Each(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -143,6 +156,7 @@ public void Each(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T
     public void Each(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -153,6 +167,7 @@ public void Each(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, re
     public void Each(Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -163,6 +178,7 @@ public void Each(Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5> callback)
     public void Each(Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -173,6 +189,7 @@ public void Each(Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5> callback)
     public void Each(Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -183,6 +200,7 @@ public void Each(Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5> callback)
     public void Each(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -193,6 +211,7 @@ public void Each(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, void> callback)
     public void Each(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -203,6 +222,7 @@ public void Each(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, void> callback)
     public void Each(delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -213,6 +233,7 @@ public void Each(delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, void> callba
     public Entity Find(Ecs.FindRefCallback<T0, T1, T2, T3, T4, T5> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -223,6 +244,7 @@ public Entity Find(Ecs.FindRefCallback<T0, T1, T2, T3, T4, T5> callback)
     public Entity Find(Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4, T5> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -233,6 +255,7 @@ public Entity Find(Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4, T5> callback)
     public Entity Find(Ecs.FindIterRefCallback<T0, T1, T2, T3, T4, T5> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -243,6 +266,7 @@ public Entity Find(Ecs.FindIterRefCallback<T0, T1, T2, T3, T4, T5> callback)
     public Entity Find(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -253,6 +277,7 @@ public Entity Find(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, boo
     public Entity Find(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -263,6 +288,7 @@ public Entity Find(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref
     public Entity Find(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -273,6 +299,7 @@ public Entity Find(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4,
     public Entity Find(Ecs.FindPointerCallback<T0, T1, T2, T3, T4, T5> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -283,6 +310,7 @@ public Entity Find(Ecs.FindPointerCallback<T0, T1, T2, T3, T4, T5> callback)
     public Entity Find(Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4, T5> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -293,6 +321,7 @@ public Entity Find(Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4, T5> callbac
     public Entity Find(Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4, T5> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -303,6 +332,7 @@ public Entity Find(Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4, T5> callback)
     public Entity Find(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -313,6 +343,7 @@ public Entity Find(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, bool> callback)
     public Entity Find(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -323,6 +354,7 @@ public Entity Find(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, bool> callbac
     public Entity Find(delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 }
\ No newline at end of file
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/IterIterable/IterIterable.IIterable/T7.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/IterIterable/IterIterable.IIterable/T7.g.cs
index 5e60a2d1..ecf8c84c 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/IterIterable/IterIterable.IIterable/T7.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/IterIterable/IterIterable.IIterable/T7.g.cs
@@ -13,6 +13,7 @@ public unsafe partial struct IterIterable<T0, T1, T2, T3, T4, T5, T6>
     public void Run(Ecs.RunCallback callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Run(ref this, callback);
     }
 
@@ -23,6 +24,7 @@ public void Run(Ecs.RunCallback callback)
     public void Run(delegate*<Iter, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Run(ref this, callback);
     }
 
@@ -33,6 +35,7 @@ public void Run(delegate*<Iter, void> callback)
     public void Iter(Ecs.IterFieldCallback<T0, T1, T2, T3, T4, T5, T6> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -43,6 +46,7 @@ public void Iter(Ecs.IterFieldCallback<T0, T1, T2, T3, T4, T5, T6> callback)
     public void Iter(Ecs.IterSpanCallback<T0, T1, T2, T3, T4, T5, T6> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -53,6 +57,7 @@ public void Iter(Ecs.IterSpanCallback<T0, T1, T2, T3, T4, T5, T6> callback)
     public void Iter(Ecs.IterPointerCallback<T0, T1, T2, T3, T4, T5, T6> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -63,6 +68,7 @@ public void Iter(Ecs.IterPointerCallback<T0, T1, T2, T3, T4, T5, T6> callback)
     public void Iter(delegate*<Iter, Field<T0>, Field<T1>, Field<T2>, Field<T3>, Field<T4>, Field<T5>, Field<T6>, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -73,6 +79,7 @@ public void Iter(delegate*<Iter, Field<T0>, Field<T1>, Field<T2>, Field<T3>, Fie
     public void Iter(delegate*<Iter, Span<T0>, Span<T1>, Span<T2>, Span<T3>, Span<T4>, Span<T5>, Span<T6>, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -83,6 +90,7 @@ public void Iter(delegate*<Iter, Span<T0>, Span<T1>, Span<T2>, Span<T3>, Span<T4
     public void Iter(delegate*<Iter, T0*, T1*, T2*, T3*, T4*, T5*, T6*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -93,6 +101,7 @@ public void Iter(delegate*<Iter, T0*, T1*, T2*, T3*, T4*, T5*, T6*, void> callba
     public void Each(Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5, T6> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -103,6 +112,7 @@ public void Each(Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5, T6> callback)
     public void Each(Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5, T6> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -113,6 +123,7 @@ public void Each(Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5, T6> callback)
     public void Each(Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5, T6> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -123,6 +134,7 @@ public void Each(Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5, T6> callback)
     public void Each(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -133,6 +145,7 @@ public void Each(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T
     public void Each(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -143,6 +156,7 @@ public void Each(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T
     public void Each(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -153,6 +167,7 @@ public void Each(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, re
     public void Each(Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5, T6> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -163,6 +178,7 @@ public void Each(Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5, T6> callback)
     public void Each(Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -173,6 +189,7 @@ public void Each(Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6> callb
     public void Each(Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5, T6> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -183,6 +200,7 @@ public void Each(Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5, T6> callbac
     public void Each(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -193,6 +211,7 @@ public void Each(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, void> callback)
     public void Each(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -203,6 +222,7 @@ public void Each(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, void> call
     public void Each(delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -213,6 +233,7 @@ public void Each(delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, void> c
     public Entity Find(Ecs.FindRefCallback<T0, T1, T2, T3, T4, T5, T6> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -223,6 +244,7 @@ public Entity Find(Ecs.FindRefCallback<T0, T1, T2, T3, T4, T5, T6> callback)
     public Entity Find(Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4, T5, T6> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -233,6 +255,7 @@ public Entity Find(Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4, T5, T6> callbac
     public Entity Find(Ecs.FindIterRefCallback<T0, T1, T2, T3, T4, T5, T6> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -243,6 +266,7 @@ public Entity Find(Ecs.FindIterRefCallback<T0, T1, T2, T3, T4, T5, T6> callback)
     public Entity Find(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -253,6 +277,7 @@ public Entity Find(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref
     public Entity Find(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -263,6 +288,7 @@ public Entity Find(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref
     public Entity Find(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -273,6 +299,7 @@ public Entity Find(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4,
     public Entity Find(Ecs.FindPointerCallback<T0, T1, T2, T3, T4, T5, T6> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -283,6 +310,7 @@ public Entity Find(Ecs.FindPointerCallback<T0, T1, T2, T3, T4, T5, T6> callback)
     public Entity Find(Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -293,6 +321,7 @@ public Entity Find(Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6> cal
     public Entity Find(Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4, T5, T6> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -303,6 +332,7 @@ public Entity Find(Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4, T5, T6> callb
     public Entity Find(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -313,6 +343,7 @@ public Entity Find(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, bool> callback)
     public Entity Find(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -323,6 +354,7 @@ public Entity Find(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, bool> ca
     public Entity Find(delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 }
\ No newline at end of file
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/IterIterable/IterIterable.IIterable/T8.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/IterIterable/IterIterable.IIterable/T8.g.cs
index fae7bff6..5023e9eb 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/IterIterable/IterIterable.IIterable/T8.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/IterIterable/IterIterable.IIterable/T8.g.cs
@@ -13,6 +13,7 @@ public unsafe partial struct IterIterable<T0, T1, T2, T3, T4, T5, T6, T7>
     public void Run(Ecs.RunCallback callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Run(ref this, callback);
     }
 
@@ -23,6 +24,7 @@ public void Run(Ecs.RunCallback callback)
     public void Run(delegate*<Iter, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Run(ref this, callback);
     }
 
@@ -33,6 +35,7 @@ public void Run(delegate*<Iter, void> callback)
     public void Iter(Ecs.IterFieldCallback<T0, T1, T2, T3, T4, T5, T6, T7> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -43,6 +46,7 @@ public void Iter(Ecs.IterFieldCallback<T0, T1, T2, T3, T4, T5, T6, T7> callback)
     public void Iter(Ecs.IterSpanCallback<T0, T1, T2, T3, T4, T5, T6, T7> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -53,6 +57,7 @@ public void Iter(Ecs.IterSpanCallback<T0, T1, T2, T3, T4, T5, T6, T7> callback)
     public void Iter(Ecs.IterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -63,6 +68,7 @@ public void Iter(Ecs.IterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7> callbac
     public void Iter(delegate*<Iter, Field<T0>, Field<T1>, Field<T2>, Field<T3>, Field<T4>, Field<T5>, Field<T6>, Field<T7>, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -73,6 +79,7 @@ public void Iter(delegate*<Iter, Field<T0>, Field<T1>, Field<T2>, Field<T3>, Fie
     public void Iter(delegate*<Iter, Span<T0>, Span<T1>, Span<T2>, Span<T3>, Span<T4>, Span<T5>, Span<T6>, Span<T7>, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -83,6 +90,7 @@ public void Iter(delegate*<Iter, Span<T0>, Span<T1>, Span<T2>, Span<T3>, Span<T4
     public void Iter(delegate*<Iter, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -93,6 +101,7 @@ public void Iter(delegate*<Iter, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, void> c
     public void Each(Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5, T6, T7> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -103,6 +112,7 @@ public void Each(Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5, T6, T7> callback)
     public void Each(Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -113,6 +123,7 @@ public void Each(Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7> callb
     public void Each(Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -123,6 +134,7 @@ public void Each(Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7> callbac
     public void Each(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -133,6 +145,7 @@ public void Each(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T
     public void Each(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -143,6 +156,7 @@ public void Each(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T
     public void Each(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -153,6 +167,7 @@ public void Each(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, re
     public void Each(Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -163,6 +178,7 @@ public void Each(Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7> callbac
     public void Each(Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -173,6 +189,7 @@ public void Each(Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7> c
     public void Each(Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -183,6 +200,7 @@ public void Each(Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7> cal
     public void Each(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -193,6 +211,7 @@ public void Each(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, void> callbac
     public void Each(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -203,6 +222,7 @@ public void Each(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, void>
     public void Each(delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -213,6 +233,7 @@ public void Each(delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, vo
     public Entity Find(Ecs.FindRefCallback<T0, T1, T2, T3, T4, T5, T6, T7> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -223,6 +244,7 @@ public Entity Find(Ecs.FindRefCallback<T0, T1, T2, T3, T4, T5, T6, T7> callback)
     public Entity Find(Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -233,6 +255,7 @@ public Entity Find(Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7> cal
     public Entity Find(Ecs.FindIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -243,6 +266,7 @@ public Entity Find(Ecs.FindIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7> callb
     public Entity Find(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -253,6 +277,7 @@ public Entity Find(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref
     public Entity Find(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -263,6 +288,7 @@ public Entity Find(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref
     public Entity Find(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -273,6 +299,7 @@ public Entity Find(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4,
     public Entity Find(Ecs.FindPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -283,6 +310,7 @@ public Entity Find(Ecs.FindPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7> callb
     public Entity Find(Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -293,6 +321,7 @@ public Entity Find(Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7>
     public Entity Find(Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -303,6 +332,7 @@ public Entity Find(Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7> c
     public Entity Find(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -313,6 +343,7 @@ public Entity Find(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, bool> callb
     public Entity Find(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -323,6 +354,7 @@ public Entity Find(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, boo
     public Entity Find(delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 }
\ No newline at end of file
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/IterIterable/IterIterable.IIterable/T9.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/IterIterable/IterIterable.IIterable/T9.g.cs
index e6b1c06e..e2c13dec 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/IterIterable/IterIterable.IIterable/T9.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/IterIterable/IterIterable.IIterable/T9.g.cs
@@ -13,6 +13,7 @@ public unsafe partial struct IterIterable<T0, T1, T2, T3, T4, T5, T6, T7, T8>
     public void Run(Ecs.RunCallback callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Run(ref this, callback);
     }
 
@@ -23,6 +24,7 @@ public void Run(Ecs.RunCallback callback)
     public void Run(delegate*<Iter, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Run(ref this, callback);
     }
 
@@ -33,6 +35,7 @@ public void Run(delegate*<Iter, void> callback)
     public void Iter(Ecs.IterFieldCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -43,6 +46,7 @@ public void Iter(Ecs.IterFieldCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> callb
     public void Iter(Ecs.IterSpanCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -53,6 +57,7 @@ public void Iter(Ecs.IterSpanCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> callba
     public void Iter(Ecs.IterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -63,6 +68,7 @@ public void Iter(Ecs.IterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> cal
     public void Iter(delegate*<Iter, Field<T0>, Field<T1>, Field<T2>, Field<T3>, Field<T4>, Field<T5>, Field<T6>, Field<T7>, Field<T8>, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -73,6 +79,7 @@ public void Iter(delegate*<Iter, Field<T0>, Field<T1>, Field<T2>, Field<T3>, Fie
     public void Iter(delegate*<Iter, Span<T0>, Span<T1>, Span<T2>, Span<T3>, Span<T4>, Span<T5>, Span<T6>, Span<T7>, Span<T8>, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -83,6 +90,7 @@ public void Iter(delegate*<Iter, Span<T0>, Span<T1>, Span<T2>, Span<T3>, Span<T4
     public void Iter(delegate*<Iter, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -93,6 +101,7 @@ public void Iter(delegate*<Iter, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, vo
     public void Each(Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -103,6 +112,7 @@ public void Each(Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> callbac
     public void Each(Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -113,6 +123,7 @@ public void Each(Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> c
     public void Each(Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -123,6 +134,7 @@ public void Each(Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> cal
     public void Each(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -133,6 +145,7 @@ public void Each(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T
     public void Each(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -143,6 +156,7 @@ public void Each(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T
     public void Each(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -153,6 +167,7 @@ public void Each(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, re
     public void Each(Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -163,6 +178,7 @@ public void Each(Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> cal
     public void Each(Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -173,6 +189,7 @@ public void Each(Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T
     public void Each(Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -183,6 +200,7 @@ public void Each(Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8>
     public void Each(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -193,6 +211,7 @@ public void Each(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, void> ca
     public void Each(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -203,6 +222,7 @@ public void Each(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*,
     public void Each(delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -213,6 +233,7 @@ public void Each(delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8
     public Entity Find(Ecs.FindRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -223,6 +244,7 @@ public Entity Find(Ecs.FindRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> callb
     public Entity Find(Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -233,6 +255,7 @@ public Entity Find(Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8>
     public Entity Find(Ecs.FindIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -243,6 +266,7 @@ public Entity Find(Ecs.FindIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> c
     public Entity Find(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -253,6 +277,7 @@ public Entity Find(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref
     public Entity Find(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -263,6 +288,7 @@ public Entity Find(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref
     public Entity Find(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -273,6 +299,7 @@ public Entity Find(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4,
     public Entity Find(Ecs.FindPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -283,6 +310,7 @@ public Entity Find(Ecs.FindPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> c
     public Entity Find(Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -293,6 +321,7 @@ public Entity Find(Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7,
     public Entity Find(Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -303,6 +332,7 @@ public Entity Find(Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T
     public Entity Find(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -313,6 +343,7 @@ public Entity Find(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, bool>
     public Entity Find(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -323,6 +354,7 @@ public Entity Find(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*
     public Entity Find(delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 }
\ No newline at end of file
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/IterIterable/IterIterable/T1.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/IterIterable/IterIterable/T1.g.cs
index aed9f63b..41201019 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/IterIterable/IterIterable/T1.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/IterIterable/IterIterable/T1.g.cs
@@ -150,6 +150,9 @@ public override int GetHashCode()
 // IIterableBase Interface
 public unsafe partial struct IterIterable<T0> : IIterableBase
 {
+    /// <inheritdoc cref="IterIterable.World"/>
+    public ref ecs_world_t* World => ref _iterIterable.World;
+    
     /// <inheritdoc cref="IterIterable.GetIter(ecs_world_t*)"/>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public ecs_iter_t GetIter(ecs_world_t* world = null)
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/IterIterable/IterIterable/T10.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/IterIterable/IterIterable/T10.g.cs
index b1d565e4..577bf055 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/IterIterable/IterIterable/T10.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/IterIterable/IterIterable/T10.g.cs
@@ -150,6 +150,9 @@ public override int GetHashCode()
 // IIterableBase Interface
 public unsafe partial struct IterIterable<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> : IIterableBase
 {
+    /// <inheritdoc cref="IterIterable.World"/>
+    public ref ecs_world_t* World => ref _iterIterable.World;
+    
     /// <inheritdoc cref="IterIterable.GetIter(ecs_world_t*)"/>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public ecs_iter_t GetIter(ecs_world_t* world = null)
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/IterIterable/IterIterable/T11.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/IterIterable/IterIterable/T11.g.cs
index cf4eb987..05660749 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/IterIterable/IterIterable/T11.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/IterIterable/IterIterable/T11.g.cs
@@ -150,6 +150,9 @@ public override int GetHashCode()
 // IIterableBase Interface
 public unsafe partial struct IterIterable<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> : IIterableBase
 {
+    /// <inheritdoc cref="IterIterable.World"/>
+    public ref ecs_world_t* World => ref _iterIterable.World;
+    
     /// <inheritdoc cref="IterIterable.GetIter(ecs_world_t*)"/>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public ecs_iter_t GetIter(ecs_world_t* world = null)
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/IterIterable/IterIterable/T12.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/IterIterable/IterIterable/T12.g.cs
index 84689098..d4eedb05 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/IterIterable/IterIterable/T12.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/IterIterable/IterIterable/T12.g.cs
@@ -150,6 +150,9 @@ public override int GetHashCode()
 // IIterableBase Interface
 public unsafe partial struct IterIterable<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> : IIterableBase
 {
+    /// <inheritdoc cref="IterIterable.World"/>
+    public ref ecs_world_t* World => ref _iterIterable.World;
+    
     /// <inheritdoc cref="IterIterable.GetIter(ecs_world_t*)"/>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public ecs_iter_t GetIter(ecs_world_t* world = null)
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/IterIterable/IterIterable/T13.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/IterIterable/IterIterable/T13.g.cs
index 08d853df..7eb478ad 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/IterIterable/IterIterable/T13.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/IterIterable/IterIterable/T13.g.cs
@@ -150,6 +150,9 @@ public override int GetHashCode()
 // IIterableBase Interface
 public unsafe partial struct IterIterable<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> : IIterableBase
 {
+    /// <inheritdoc cref="IterIterable.World"/>
+    public ref ecs_world_t* World => ref _iterIterable.World;
+    
     /// <inheritdoc cref="IterIterable.GetIter(ecs_world_t*)"/>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public ecs_iter_t GetIter(ecs_world_t* world = null)
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/IterIterable/IterIterable/T14.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/IterIterable/IterIterable/T14.g.cs
index 5b6ba2e0..cf672922 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/IterIterable/IterIterable/T14.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/IterIterable/IterIterable/T14.g.cs
@@ -150,6 +150,9 @@ public override int GetHashCode()
 // IIterableBase Interface
 public unsafe partial struct IterIterable<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> : IIterableBase
 {
+    /// <inheritdoc cref="IterIterable.World"/>
+    public ref ecs_world_t* World => ref _iterIterable.World;
+    
     /// <inheritdoc cref="IterIterable.GetIter(ecs_world_t*)"/>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public ecs_iter_t GetIter(ecs_world_t* world = null)
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/IterIterable/IterIterable/T15.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/IterIterable/IterIterable/T15.g.cs
index 45e04dc8..c78a8056 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/IterIterable/IterIterable/T15.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/IterIterable/IterIterable/T15.g.cs
@@ -150,6 +150,9 @@ public override int GetHashCode()
 // IIterableBase Interface
 public unsafe partial struct IterIterable<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> : IIterableBase
 {
+    /// <inheritdoc cref="IterIterable.World"/>
+    public ref ecs_world_t* World => ref _iterIterable.World;
+    
     /// <inheritdoc cref="IterIterable.GetIter(ecs_world_t*)"/>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public ecs_iter_t GetIter(ecs_world_t* world = null)
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/IterIterable/IterIterable/T16.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/IterIterable/IterIterable/T16.g.cs
index 3b291697..ebaf3e3f 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/IterIterable/IterIterable/T16.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/IterIterable/IterIterable/T16.g.cs
@@ -150,6 +150,9 @@ public override int GetHashCode()
 // IIterableBase Interface
 public unsafe partial struct IterIterable<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> : IIterableBase
 {
+    /// <inheritdoc cref="IterIterable.World"/>
+    public ref ecs_world_t* World => ref _iterIterable.World;
+    
     /// <inheritdoc cref="IterIterable.GetIter(ecs_world_t*)"/>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public ecs_iter_t GetIter(ecs_world_t* world = null)
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/IterIterable/IterIterable/T2.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/IterIterable/IterIterable/T2.g.cs
index b18392af..50f9bbf6 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/IterIterable/IterIterable/T2.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/IterIterable/IterIterable/T2.g.cs
@@ -150,6 +150,9 @@ public override int GetHashCode()
 // IIterableBase Interface
 public unsafe partial struct IterIterable<T0, T1> : IIterableBase
 {
+    /// <inheritdoc cref="IterIterable.World"/>
+    public ref ecs_world_t* World => ref _iterIterable.World;
+    
     /// <inheritdoc cref="IterIterable.GetIter(ecs_world_t*)"/>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public ecs_iter_t GetIter(ecs_world_t* world = null)
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/IterIterable/IterIterable/T3.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/IterIterable/IterIterable/T3.g.cs
index 4ba6a270..0b75d025 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/IterIterable/IterIterable/T3.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/IterIterable/IterIterable/T3.g.cs
@@ -150,6 +150,9 @@ public override int GetHashCode()
 // IIterableBase Interface
 public unsafe partial struct IterIterable<T0, T1, T2> : IIterableBase
 {
+    /// <inheritdoc cref="IterIterable.World"/>
+    public ref ecs_world_t* World => ref _iterIterable.World;
+    
     /// <inheritdoc cref="IterIterable.GetIter(ecs_world_t*)"/>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public ecs_iter_t GetIter(ecs_world_t* world = null)
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/IterIterable/IterIterable/T4.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/IterIterable/IterIterable/T4.g.cs
index 567198c6..d095358a 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/IterIterable/IterIterable/T4.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/IterIterable/IterIterable/T4.g.cs
@@ -150,6 +150,9 @@ public override int GetHashCode()
 // IIterableBase Interface
 public unsafe partial struct IterIterable<T0, T1, T2, T3> : IIterableBase
 {
+    /// <inheritdoc cref="IterIterable.World"/>
+    public ref ecs_world_t* World => ref _iterIterable.World;
+    
     /// <inheritdoc cref="IterIterable.GetIter(ecs_world_t*)"/>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public ecs_iter_t GetIter(ecs_world_t* world = null)
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/IterIterable/IterIterable/T5.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/IterIterable/IterIterable/T5.g.cs
index a2c907ef..f13deaaf 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/IterIterable/IterIterable/T5.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/IterIterable/IterIterable/T5.g.cs
@@ -150,6 +150,9 @@ public override int GetHashCode()
 // IIterableBase Interface
 public unsafe partial struct IterIterable<T0, T1, T2, T3, T4> : IIterableBase
 {
+    /// <inheritdoc cref="IterIterable.World"/>
+    public ref ecs_world_t* World => ref _iterIterable.World;
+    
     /// <inheritdoc cref="IterIterable.GetIter(ecs_world_t*)"/>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public ecs_iter_t GetIter(ecs_world_t* world = null)
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/IterIterable/IterIterable/T6.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/IterIterable/IterIterable/T6.g.cs
index e8806a48..257f5f8b 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/IterIterable/IterIterable/T6.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/IterIterable/IterIterable/T6.g.cs
@@ -150,6 +150,9 @@ public override int GetHashCode()
 // IIterableBase Interface
 public unsafe partial struct IterIterable<T0, T1, T2, T3, T4, T5> : IIterableBase
 {
+    /// <inheritdoc cref="IterIterable.World"/>
+    public ref ecs_world_t* World => ref _iterIterable.World;
+    
     /// <inheritdoc cref="IterIterable.GetIter(ecs_world_t*)"/>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public ecs_iter_t GetIter(ecs_world_t* world = null)
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/IterIterable/IterIterable/T7.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/IterIterable/IterIterable/T7.g.cs
index 3f0a342d..6795fce1 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/IterIterable/IterIterable/T7.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/IterIterable/IterIterable/T7.g.cs
@@ -150,6 +150,9 @@ public override int GetHashCode()
 // IIterableBase Interface
 public unsafe partial struct IterIterable<T0, T1, T2, T3, T4, T5, T6> : IIterableBase
 {
+    /// <inheritdoc cref="IterIterable.World"/>
+    public ref ecs_world_t* World => ref _iterIterable.World;
+    
     /// <inheritdoc cref="IterIterable.GetIter(ecs_world_t*)"/>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public ecs_iter_t GetIter(ecs_world_t* world = null)
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/IterIterable/IterIterable/T8.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/IterIterable/IterIterable/T8.g.cs
index e1275de5..7e29d704 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/IterIterable/IterIterable/T8.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/IterIterable/IterIterable/T8.g.cs
@@ -150,6 +150,9 @@ public override int GetHashCode()
 // IIterableBase Interface
 public unsafe partial struct IterIterable<T0, T1, T2, T3, T4, T5, T6, T7> : IIterableBase
 {
+    /// <inheritdoc cref="IterIterable.World"/>
+    public ref ecs_world_t* World => ref _iterIterable.World;
+    
     /// <inheritdoc cref="IterIterable.GetIter(ecs_world_t*)"/>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public ecs_iter_t GetIter(ecs_world_t* world = null)
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/IterIterable/IterIterable/T9.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/IterIterable/IterIterable/T9.g.cs
index 18770a1d..de331177 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/IterIterable/IterIterable/T9.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/IterIterable/IterIterable/T9.g.cs
@@ -150,6 +150,9 @@ public override int GetHashCode()
 // IIterableBase Interface
 public unsafe partial struct IterIterable<T0, T1, T2, T3, T4, T5, T6, T7, T8> : IIterableBase
 {
+    /// <inheritdoc cref="IterIterable.World"/>
+    public ref ecs_world_t* World => ref _iterIterable.World;
+    
     /// <inheritdoc cref="IterIterable.GetIter(ecs_world_t*)"/>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public ecs_iter_t GetIter(ecs_world_t* world = null)
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/ObserverBuilder/ObserverBuilder.NodeBuilder/T1.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/ObserverBuilder/ObserverBuilder.NodeBuilder/T1.g.cs
index fe0bda26..90bc2af6 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/ObserverBuilder/ObserverBuilder.NodeBuilder/T1.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/ObserverBuilder/ObserverBuilder.NodeBuilder/T1.g.cs
@@ -14,6 +14,7 @@ public unsafe partial struct ObserverBuilder<T0>
     public Observer<T0> Run(Ecs.RunCallback callback)
     {
         TypeHelper<T0>.AssertReferenceTypes(true);
+        TypeHelper<T0>.AssertSparseTypes(World, true);
         return SetRun(callback, Pointers<T0>.RunCallbackDelegate).Build();
     }
 
@@ -24,6 +25,7 @@ public Observer<T0> Run(Ecs.RunCallback callback)
     public Observer<T0> Run(delegate*<Iter, void> callback)
     {
         TypeHelper<T0>.AssertReferenceTypes(true);
+        TypeHelper<T0>.AssertSparseTypes(World, true);
         return SetRun((IntPtr)callback, Pointers<T0>.RunCallbackPointer).Build();
     }
 
@@ -34,6 +36,7 @@ public Observer<T0> Run(delegate*<Iter, void> callback)
     public Observer<T0> Iter(Ecs.IterFieldCallback<T0> callback)
     {
         TypeHelper<T0>.AssertReferenceTypes(true);
+        TypeHelper<T0>.AssertSparseTypes(World, false);
         return SetCallback(callback, Pointers<T0>.IterFieldCallbackDelegate).Build();
     }
 
@@ -44,6 +47,7 @@ public Observer<T0> Iter(Ecs.IterFieldCallback<T0> callback)
     public Observer<T0> Iter(Ecs.IterSpanCallback<T0> callback)
     {
         TypeHelper<T0>.AssertReferenceTypes(false);
+        TypeHelper<T0>.AssertSparseTypes(World, false);
         return SetCallback(callback, Pointers<T0>.IterSpanCallbackDelegate).Build();
     }
 
@@ -54,6 +58,7 @@ public Observer<T0> Iter(Ecs.IterSpanCallback<T0> callback)
     public Observer<T0> Iter(Ecs.IterPointerCallback<T0> callback)
     {
         TypeHelper<T0>.AssertReferenceTypes(false);
+        TypeHelper<T0>.AssertSparseTypes(World, false);
         return SetCallback(callback, Pointers<T0>.IterPointerCallbackDelegate).Build();
     }
 
@@ -64,6 +69,7 @@ public Observer<T0> Iter(Ecs.IterPointerCallback<T0> callback)
     public Observer<T0> Iter(delegate*<Iter, Field<T0>, void> callback)
     {
         TypeHelper<T0>.AssertReferenceTypes(true);
+        TypeHelper<T0>.AssertSparseTypes(World, false);
         return SetCallback((IntPtr)callback, Pointers<T0>.IterFieldCallbackPointer).Build();
     }
 
@@ -74,6 +80,7 @@ public Observer<T0> Iter(delegate*<Iter, Field<T0>, void> callback)
     public Observer<T0> Iter(delegate*<Iter, Span<T0>, void> callback)
     {
         TypeHelper<T0>.AssertReferenceTypes(false);
+        TypeHelper<T0>.AssertSparseTypes(World, false);
         return SetCallback((IntPtr)callback, Pointers<T0>.IterSpanCallbackPointer).Build();
     }
 
@@ -84,6 +91,7 @@ public Observer<T0> Iter(delegate*<Iter, Span<T0>, void> callback)
     public Observer<T0> Iter(delegate*<Iter, T0*, void> callback)
     {
         TypeHelper<T0>.AssertReferenceTypes(false);
+        TypeHelper<T0>.AssertSparseTypes(World, false);
         return SetCallback((IntPtr)callback, Pointers<T0>.IterPointerCallbackPointer).Build();
     }
 
@@ -94,6 +102,7 @@ public Observer<T0> Iter(delegate*<Iter, T0*, void> callback)
     public Observer<T0> Each(Ecs.EachRefCallback<T0> callback)
     {
         TypeHelper<T0>.AssertReferenceTypes(true);
+        TypeHelper<T0>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0>.EachRefCallbackDelegate).Build();
     }
 
@@ -104,6 +113,7 @@ public Observer<T0> Each(Ecs.EachRefCallback<T0> callback)
     public Observer<T0> Each(Ecs.EachEntityRefCallback<T0> callback)
     {
         TypeHelper<T0>.AssertReferenceTypes(true);
+        TypeHelper<T0>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0>.EachEntityRefCallbackDelegate).Build();
     }
 
@@ -114,6 +124,7 @@ public Observer<T0> Each(Ecs.EachEntityRefCallback<T0> callback)
     public Observer<T0> Each(Ecs.EachIterRefCallback<T0> callback)
     {
         TypeHelper<T0>.AssertReferenceTypes(true);
+        TypeHelper<T0>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0>.EachIterRefCallbackDelegate).Build();
     }
 
@@ -124,6 +135,7 @@ public Observer<T0> Each(Ecs.EachIterRefCallback<T0> callback)
     public Observer<T0> Each(delegate*<ref T0, void> callback)
     {
         TypeHelper<T0>.AssertReferenceTypes(true);
+        TypeHelper<T0>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0>.EachRefCallbackPointer).Build();
     }
 
@@ -134,6 +146,7 @@ public Observer<T0> Each(delegate*<ref T0, void> callback)
     public Observer<T0> Each(delegate*<Entity, ref T0, void> callback)
     {
         TypeHelper<T0>.AssertReferenceTypes(true);
+        TypeHelper<T0>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0>.EachEntityRefCallbackPointer).Build();
     }
 
@@ -144,6 +157,7 @@ public Observer<T0> Each(delegate*<Entity, ref T0, void> callback)
     public Observer<T0> Each(delegate*<Iter, int, ref T0, void> callback)
     {
         TypeHelper<T0>.AssertReferenceTypes(true);
+        TypeHelper<T0>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0>.EachIterRefCallbackPointer).Build();
     }
 
@@ -154,6 +168,7 @@ public Observer<T0> Each(delegate*<Iter, int, ref T0, void> callback)
     public Observer<T0> Each(Ecs.EachPointerCallback<T0> callback)
     {
         TypeHelper<T0>.AssertReferenceTypes(false);
+        TypeHelper<T0>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0>.EachPointerCallbackDelegate).Build();
     }
 
@@ -164,6 +179,7 @@ public Observer<T0> Each(Ecs.EachPointerCallback<T0> callback)
     public Observer<T0> Each(Ecs.EachEntityPointerCallback<T0> callback)
     {
         TypeHelper<T0>.AssertReferenceTypes(false);
+        TypeHelper<T0>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0>.EachEntityPointerCallbackDelegate).Build();
     }
 
@@ -174,6 +190,7 @@ public Observer<T0> Each(Ecs.EachEntityPointerCallback<T0> callback)
     public Observer<T0> Each(Ecs.EachIterPointerCallback<T0> callback)
     {
         TypeHelper<T0>.AssertReferenceTypes(false);
+        TypeHelper<T0>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0>.EachIterPointerCallbackDelegate).Build();
     }
 
@@ -184,6 +201,7 @@ public Observer<T0> Each(Ecs.EachIterPointerCallback<T0> callback)
     public Observer<T0> Each(delegate*<T0*, void> callback)
     {
         TypeHelper<T0>.AssertReferenceTypes(false);
+        TypeHelper<T0>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0>.EachPointerCallbackPointer).Build();
     }
 
@@ -194,6 +212,7 @@ public Observer<T0> Each(delegate*<T0*, void> callback)
     public Observer<T0> Each(delegate*<Entity, T0*, void> callback)
     {
         TypeHelper<T0>.AssertReferenceTypes(false);
+        TypeHelper<T0>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0>.EachEntityPointerCallbackPointer).Build();
     }
 
@@ -204,6 +223,7 @@ public Observer<T0> Each(delegate*<Entity, T0*, void> callback)
     public Observer<T0> Each(delegate*<Iter, int, T0*, void> callback)
     {
         TypeHelper<T0>.AssertReferenceTypes(false);
+        TypeHelper<T0>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0>.EachIterPointerCallbackPointer).Build();
     }
 }
\ No newline at end of file
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/ObserverBuilder/ObserverBuilder.NodeBuilder/T10.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/ObserverBuilder/ObserverBuilder.NodeBuilder/T10.g.cs
index b735af32..eb6343bf 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/ObserverBuilder/ObserverBuilder.NodeBuilder/T10.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/ObserverBuilder/ObserverBuilder.NodeBuilder/T10.g.cs
@@ -14,6 +14,7 @@ public unsafe partial struct ObserverBuilder<T0, T1, T2, T3, T4, T5, T6, T7, T8,
     public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Run(Ecs.RunCallback callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertSparseTypes(World, true);
         return SetRun(callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.RunCallbackDelegate).Build();
     }
 
@@ -24,6 +25,7 @@ public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Run(Ecs.RunCallback call
     public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Run(delegate*<Iter, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertSparseTypes(World, true);
         return SetRun((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.RunCallbackPointer).Build();
     }
 
@@ -34,6 +36,7 @@ public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Run(delegate*<Iter, void
     public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Iter(Ecs.IterFieldCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertSparseTypes(World, false);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.IterFieldCallbackDelegate).Build();
     }
 
@@ -44,6 +47,7 @@ public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Iter(Ecs.IterFieldCallba
     public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Iter(Ecs.IterSpanCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertSparseTypes(World, false);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.IterSpanCallbackDelegate).Build();
     }
 
@@ -54,6 +58,7 @@ public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Iter(Ecs.IterSpanCallbac
     public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Iter(Ecs.IterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertSparseTypes(World, false);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.IterPointerCallbackDelegate).Build();
     }
 
@@ -64,6 +69,7 @@ public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Iter(Ecs.IterPointerCall
     public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Iter(delegate*<Iter, Field<T0>, Field<T1>, Field<T2>, Field<T3>, Field<T4>, Field<T5>, Field<T6>, Field<T7>, Field<T8>, Field<T9>, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertSparseTypes(World, false);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.IterFieldCallbackPointer).Build();
     }
 
@@ -74,6 +80,7 @@ public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Iter(delegate*<Iter, Fie
     public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Iter(delegate*<Iter, Span<T0>, Span<T1>, Span<T2>, Span<T3>, Span<T4>, Span<T5>, Span<T6>, Span<T7>, Span<T8>, Span<T9>, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertSparseTypes(World, false);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.IterSpanCallbackPointer).Build();
     }
 
@@ -84,6 +91,7 @@ public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Iter(delegate*<Iter, Spa
     public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Iter(delegate*<Iter, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertSparseTypes(World, false);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.IterPointerCallbackPointer).Build();
     }
 
@@ -94,6 +102,7 @@ public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Iter(delegate*<Iter, T0*
     public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Each(Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.EachRefCallbackDelegate).Build();
     }
 
@@ -104,6 +113,7 @@ public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Each(Ecs.EachRefCallback
     public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Each(Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.EachEntityRefCallbackDelegate).Build();
     }
 
@@ -114,6 +124,7 @@ public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Each(Ecs.EachEntityRefCa
     public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Each(Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.EachIterRefCallbackDelegate).Build();
     }
 
@@ -124,6 +135,7 @@ public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Each(Ecs.EachIterRefCall
     public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Each(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.EachRefCallbackPointer).Build();
     }
 
@@ -134,6 +146,7 @@ public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Each(delegate*<ref T0, r
     public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Each(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.EachEntityRefCallbackPointer).Build();
     }
 
@@ -144,6 +157,7 @@ public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Each(delegate*<Entity, r
     public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Each(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.EachIterRefCallbackPointer).Build();
     }
 
@@ -154,6 +168,7 @@ public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Each(delegate*<Iter, int
     public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Each(Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.EachPointerCallbackDelegate).Build();
     }
 
@@ -164,6 +179,7 @@ public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Each(Ecs.EachPointerCall
     public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Each(Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.EachEntityPointerCallbackDelegate).Build();
     }
 
@@ -174,6 +190,7 @@ public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Each(Ecs.EachEntityPoint
     public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Each(Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.EachIterPointerCallbackDelegate).Build();
     }
 
@@ -184,6 +201,7 @@ public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Each(Ecs.EachIterPointer
     public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Each(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.EachPointerCallbackPointer).Build();
     }
 
@@ -194,6 +212,7 @@ public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Each(delegate*<T0*, T1*,
     public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Each(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.EachEntityPointerCallbackPointer).Build();
     }
 
@@ -204,6 +223,7 @@ public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Each(delegate*<Entity, T
     public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Each(delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.EachIterPointerCallbackPointer).Build();
     }
 }
\ No newline at end of file
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/ObserverBuilder/ObserverBuilder.NodeBuilder/T11.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/ObserverBuilder/ObserverBuilder.NodeBuilder/T11.g.cs
index c16013a0..c279c053 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/ObserverBuilder/ObserverBuilder.NodeBuilder/T11.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/ObserverBuilder/ObserverBuilder.NodeBuilder/T11.g.cs
@@ -14,6 +14,7 @@ public unsafe partial struct ObserverBuilder<T0, T1, T2, T3, T4, T5, T6, T7, T8,
     public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Run(Ecs.RunCallback callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertSparseTypes(World, true);
         return SetRun(callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.RunCallbackDelegate).Build();
     }
 
@@ -24,6 +25,7 @@ public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Run(Ecs.RunCallback
     public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Run(delegate*<Iter, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertSparseTypes(World, true);
         return SetRun((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.RunCallbackPointer).Build();
     }
 
@@ -34,6 +36,7 @@ public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Run(delegate*<Iter,
     public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Iter(Ecs.IterFieldCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertSparseTypes(World, false);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.IterFieldCallbackDelegate).Build();
     }
 
@@ -44,6 +47,7 @@ public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Iter(Ecs.IterFieldC
     public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Iter(Ecs.IterSpanCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertSparseTypes(World, false);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.IterSpanCallbackDelegate).Build();
     }
 
@@ -54,6 +58,7 @@ public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Iter(Ecs.IterSpanCa
     public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Iter(Ecs.IterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertSparseTypes(World, false);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.IterPointerCallbackDelegate).Build();
     }
 
@@ -64,6 +69,7 @@ public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Iter(Ecs.IterPointe
     public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Iter(delegate*<Iter, Field<T0>, Field<T1>, Field<T2>, Field<T3>, Field<T4>, Field<T5>, Field<T6>, Field<T7>, Field<T8>, Field<T9>, Field<T10>, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertSparseTypes(World, false);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.IterFieldCallbackPointer).Build();
     }
 
@@ -74,6 +80,7 @@ public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Iter(delegate*<Iter
     public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Iter(delegate*<Iter, Span<T0>, Span<T1>, Span<T2>, Span<T3>, Span<T4>, Span<T5>, Span<T6>, Span<T7>, Span<T8>, Span<T9>, Span<T10>, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertSparseTypes(World, false);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.IterSpanCallbackPointer).Build();
     }
 
@@ -84,6 +91,7 @@ public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Iter(delegate*<Iter
     public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Iter(delegate*<Iter, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertSparseTypes(World, false);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.IterPointerCallbackPointer).Build();
     }
 
@@ -94,6 +102,7 @@ public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Iter(delegate*<Iter
     public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Each(Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.EachRefCallbackDelegate).Build();
     }
 
@@ -104,6 +113,7 @@ public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Each(Ecs.EachRefCal
     public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Each(Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.EachEntityRefCallbackDelegate).Build();
     }
 
@@ -114,6 +124,7 @@ public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Each(Ecs.EachEntity
     public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Each(Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.EachIterRefCallbackDelegate).Build();
     }
 
@@ -124,6 +135,7 @@ public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Each(Ecs.EachIterRe
     public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Each(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.EachRefCallbackPointer).Build();
     }
 
@@ -134,6 +146,7 @@ public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Each(delegate*<ref
     public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Each(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.EachEntityRefCallbackPointer).Build();
     }
 
@@ -144,6 +157,7 @@ public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Each(delegate*<Enti
     public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Each(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.EachIterRefCallbackPointer).Build();
     }
 
@@ -154,6 +168,7 @@ public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Each(delegate*<Iter
     public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Each(Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.EachPointerCallbackDelegate).Build();
     }
 
@@ -164,6 +179,7 @@ public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Each(Ecs.EachPointe
     public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Each(Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.EachEntityPointerCallbackDelegate).Build();
     }
 
@@ -174,6 +190,7 @@ public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Each(Ecs.EachEntity
     public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Each(Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.EachIterPointerCallbackDelegate).Build();
     }
 
@@ -184,6 +201,7 @@ public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Each(Ecs.EachIterPo
     public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Each(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.EachPointerCallbackPointer).Build();
     }
 
@@ -194,6 +212,7 @@ public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Each(delegate*<T0*,
     public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Each(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.EachEntityPointerCallbackPointer).Build();
     }
 
@@ -204,6 +223,7 @@ public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Each(delegate*<Enti
     public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Each(delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.EachIterPointerCallbackPointer).Build();
     }
 }
\ No newline at end of file
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/ObserverBuilder/ObserverBuilder.NodeBuilder/T12.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/ObserverBuilder/ObserverBuilder.NodeBuilder/T12.g.cs
index e651e8e8..bb71f060 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/ObserverBuilder/ObserverBuilder.NodeBuilder/T12.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/ObserverBuilder/ObserverBuilder.NodeBuilder/T12.g.cs
@@ -14,6 +14,7 @@ public unsafe partial struct ObserverBuilder<T0, T1, T2, T3, T4, T5, T6, T7, T8,
     public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Run(Ecs.RunCallback callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertSparseTypes(World, true);
         return SetRun(callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.RunCallbackDelegate).Build();
     }
 
@@ -24,6 +25,7 @@ public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Run(Ecs.RunCal
     public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Run(delegate*<Iter, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertSparseTypes(World, true);
         return SetRun((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.RunCallbackPointer).Build();
     }
 
@@ -34,6 +36,7 @@ public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Run(delegate*<
     public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Iter(Ecs.IterFieldCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertSparseTypes(World, false);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.IterFieldCallbackDelegate).Build();
     }
 
@@ -44,6 +47,7 @@ public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Iter(Ecs.IterF
     public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Iter(Ecs.IterSpanCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertSparseTypes(World, false);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.IterSpanCallbackDelegate).Build();
     }
 
@@ -54,6 +58,7 @@ public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Iter(Ecs.IterS
     public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Iter(Ecs.IterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertSparseTypes(World, false);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.IterPointerCallbackDelegate).Build();
     }
 
@@ -64,6 +69,7 @@ public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Iter(Ecs.IterP
     public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Iter(delegate*<Iter, Field<T0>, Field<T1>, Field<T2>, Field<T3>, Field<T4>, Field<T5>, Field<T6>, Field<T7>, Field<T8>, Field<T9>, Field<T10>, Field<T11>, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertSparseTypes(World, false);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.IterFieldCallbackPointer).Build();
     }
 
@@ -74,6 +80,7 @@ public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Iter(delegate*
     public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Iter(delegate*<Iter, Span<T0>, Span<T1>, Span<T2>, Span<T3>, Span<T4>, Span<T5>, Span<T6>, Span<T7>, Span<T8>, Span<T9>, Span<T10>, Span<T11>, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertSparseTypes(World, false);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.IterSpanCallbackPointer).Build();
     }
 
@@ -84,6 +91,7 @@ public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Iter(delegate*
     public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Iter(delegate*<Iter, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertSparseTypes(World, false);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.IterPointerCallbackPointer).Build();
     }
 
@@ -94,6 +102,7 @@ public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Iter(delegate*
     public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Each(Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.EachRefCallbackDelegate).Build();
     }
 
@@ -104,6 +113,7 @@ public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Each(Ecs.EachR
     public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Each(Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.EachEntityRefCallbackDelegate).Build();
     }
 
@@ -114,6 +124,7 @@ public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Each(Ecs.EachE
     public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Each(Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.EachIterRefCallbackDelegate).Build();
     }
 
@@ -124,6 +135,7 @@ public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Each(Ecs.EachI
     public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Each(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.EachRefCallbackPointer).Build();
     }
 
@@ -134,6 +146,7 @@ public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Each(delegate*
     public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Each(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.EachEntityRefCallbackPointer).Build();
     }
 
@@ -144,6 +157,7 @@ public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Each(delegate*
     public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Each(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.EachIterRefCallbackPointer).Build();
     }
 
@@ -154,6 +168,7 @@ public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Each(delegate*
     public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Each(Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.EachPointerCallbackDelegate).Build();
     }
 
@@ -164,6 +179,7 @@ public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Each(Ecs.EachP
     public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Each(Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.EachEntityPointerCallbackDelegate).Build();
     }
 
@@ -174,6 +190,7 @@ public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Each(Ecs.EachE
     public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Each(Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.EachIterPointerCallbackDelegate).Build();
     }
 
@@ -184,6 +201,7 @@ public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Each(Ecs.EachI
     public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Each(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.EachPointerCallbackPointer).Build();
     }
 
@@ -194,6 +212,7 @@ public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Each(delegate*
     public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Each(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.EachEntityPointerCallbackPointer).Build();
     }
 
@@ -204,6 +223,7 @@ public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Each(delegate*
     public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Each(delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.EachIterPointerCallbackPointer).Build();
     }
 }
\ No newline at end of file
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/ObserverBuilder/ObserverBuilder.NodeBuilder/T13.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/ObserverBuilder/ObserverBuilder.NodeBuilder/T13.g.cs
index d33bb8e3..a9dba17a 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/ObserverBuilder/ObserverBuilder.NodeBuilder/T13.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/ObserverBuilder/ObserverBuilder.NodeBuilder/T13.g.cs
@@ -14,6 +14,7 @@ public unsafe partial struct ObserverBuilder<T0, T1, T2, T3, T4, T5, T6, T7, T8,
     public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> Run(Ecs.RunCallback callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertSparseTypes(World, true);
         return SetRun(callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.RunCallbackDelegate).Build();
     }
 
@@ -24,6 +25,7 @@ public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> Run(Ecs.R
     public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> Run(delegate*<Iter, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertSparseTypes(World, true);
         return SetRun((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.RunCallbackPointer).Build();
     }
 
@@ -34,6 +36,7 @@ public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> Run(deleg
     public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> Iter(Ecs.IterFieldCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertSparseTypes(World, false);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.IterFieldCallbackDelegate).Build();
     }
 
@@ -44,6 +47,7 @@ public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> Iter(Ecs.
     public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> Iter(Ecs.IterSpanCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertSparseTypes(World, false);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.IterSpanCallbackDelegate).Build();
     }
 
@@ -54,6 +58,7 @@ public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> Iter(Ecs.
     public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> Iter(Ecs.IterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertSparseTypes(World, false);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.IterPointerCallbackDelegate).Build();
     }
 
@@ -64,6 +69,7 @@ public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> Iter(Ecs.
     public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> Iter(delegate*<Iter, Field<T0>, Field<T1>, Field<T2>, Field<T3>, Field<T4>, Field<T5>, Field<T6>, Field<T7>, Field<T8>, Field<T9>, Field<T10>, Field<T11>, Field<T12>, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertSparseTypes(World, false);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.IterFieldCallbackPointer).Build();
     }
 
@@ -74,6 +80,7 @@ public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> Iter(dele
     public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> Iter(delegate*<Iter, Span<T0>, Span<T1>, Span<T2>, Span<T3>, Span<T4>, Span<T5>, Span<T6>, Span<T7>, Span<T8>, Span<T9>, Span<T10>, Span<T11>, Span<T12>, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertSparseTypes(World, false);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.IterSpanCallbackPointer).Build();
     }
 
@@ -84,6 +91,7 @@ public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> Iter(dele
     public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> Iter(delegate*<Iter, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertSparseTypes(World, false);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.IterPointerCallbackPointer).Build();
     }
 
@@ -94,6 +102,7 @@ public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> Iter(dele
     public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> Each(Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.EachRefCallbackDelegate).Build();
     }
 
@@ -104,6 +113,7 @@ public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> Each(Ecs.
     public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> Each(Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.EachEntityRefCallbackDelegate).Build();
     }
 
@@ -114,6 +124,7 @@ public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> Each(Ecs.
     public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> Each(Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.EachIterRefCallbackDelegate).Build();
     }
 
@@ -124,6 +135,7 @@ public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> Each(Ecs.
     public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> Each(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.EachRefCallbackPointer).Build();
     }
 
@@ -134,6 +146,7 @@ public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> Each(dele
     public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> Each(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.EachEntityRefCallbackPointer).Build();
     }
 
@@ -144,6 +157,7 @@ public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> Each(dele
     public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> Each(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.EachIterRefCallbackPointer).Build();
     }
 
@@ -154,6 +168,7 @@ public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> Each(dele
     public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> Each(Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.EachPointerCallbackDelegate).Build();
     }
 
@@ -164,6 +179,7 @@ public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> Each(Ecs.
     public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> Each(Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.EachEntityPointerCallbackDelegate).Build();
     }
 
@@ -174,6 +190,7 @@ public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> Each(Ecs.
     public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> Each(Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.EachIterPointerCallbackDelegate).Build();
     }
 
@@ -184,6 +201,7 @@ public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> Each(Ecs.
     public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> Each(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.EachPointerCallbackPointer).Build();
     }
 
@@ -194,6 +212,7 @@ public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> Each(dele
     public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> Each(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.EachEntityPointerCallbackPointer).Build();
     }
 
@@ -204,6 +223,7 @@ public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> Each(dele
     public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> Each(delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.EachIterPointerCallbackPointer).Build();
     }
 }
\ No newline at end of file
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/ObserverBuilder/ObserverBuilder.NodeBuilder/T14.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/ObserverBuilder/ObserverBuilder.NodeBuilder/T14.g.cs
index 4d3f489f..99b7cfc8 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/ObserverBuilder/ObserverBuilder.NodeBuilder/T14.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/ObserverBuilder/ObserverBuilder.NodeBuilder/T14.g.cs
@@ -14,6 +14,7 @@ public unsafe partial struct ObserverBuilder<T0, T1, T2, T3, T4, T5, T6, T7, T8,
     public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> Run(Ecs.RunCallback callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertSparseTypes(World, true);
         return SetRun(callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.RunCallbackDelegate).Build();
     }
 
@@ -24,6 +25,7 @@ public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> Run(
     public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> Run(delegate*<Iter, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertSparseTypes(World, true);
         return SetRun((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.RunCallbackPointer).Build();
     }
 
@@ -34,6 +36,7 @@ public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> Run(
     public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> Iter(Ecs.IterFieldCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertSparseTypes(World, false);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.IterFieldCallbackDelegate).Build();
     }
 
@@ -44,6 +47,7 @@ public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> Iter
     public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> Iter(Ecs.IterSpanCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertSparseTypes(World, false);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.IterSpanCallbackDelegate).Build();
     }
 
@@ -54,6 +58,7 @@ public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> Iter
     public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> Iter(Ecs.IterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertSparseTypes(World, false);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.IterPointerCallbackDelegate).Build();
     }
 
@@ -64,6 +69,7 @@ public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> Iter
     public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> Iter(delegate*<Iter, Field<T0>, Field<T1>, Field<T2>, Field<T3>, Field<T4>, Field<T5>, Field<T6>, Field<T7>, Field<T8>, Field<T9>, Field<T10>, Field<T11>, Field<T12>, Field<T13>, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertSparseTypes(World, false);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.IterFieldCallbackPointer).Build();
     }
 
@@ -74,6 +80,7 @@ public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> Iter
     public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> Iter(delegate*<Iter, Span<T0>, Span<T1>, Span<T2>, Span<T3>, Span<T4>, Span<T5>, Span<T6>, Span<T7>, Span<T8>, Span<T9>, Span<T10>, Span<T11>, Span<T12>, Span<T13>, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertSparseTypes(World, false);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.IterSpanCallbackPointer).Build();
     }
 
@@ -84,6 +91,7 @@ public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> Iter
     public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> Iter(delegate*<Iter, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertSparseTypes(World, false);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.IterPointerCallbackPointer).Build();
     }
 
@@ -94,6 +102,7 @@ public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> Iter
     public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> Each(Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.EachRefCallbackDelegate).Build();
     }
 
@@ -104,6 +113,7 @@ public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> Each
     public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> Each(Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.EachEntityRefCallbackDelegate).Build();
     }
 
@@ -114,6 +124,7 @@ public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> Each
     public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> Each(Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.EachIterRefCallbackDelegate).Build();
     }
 
@@ -124,6 +135,7 @@ public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> Each
     public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> Each(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.EachRefCallbackPointer).Build();
     }
 
@@ -134,6 +146,7 @@ public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> Each
     public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> Each(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.EachEntityRefCallbackPointer).Build();
     }
 
@@ -144,6 +157,7 @@ public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> Each
     public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> Each(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.EachIterRefCallbackPointer).Build();
     }
 
@@ -154,6 +168,7 @@ public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> Each
     public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> Each(Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.EachPointerCallbackDelegate).Build();
     }
 
@@ -164,6 +179,7 @@ public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> Each
     public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> Each(Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.EachEntityPointerCallbackDelegate).Build();
     }
 
@@ -174,6 +190,7 @@ public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> Each
     public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> Each(Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.EachIterPointerCallbackDelegate).Build();
     }
 
@@ -184,6 +201,7 @@ public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> Each
     public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> Each(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.EachPointerCallbackPointer).Build();
     }
 
@@ -194,6 +212,7 @@ public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> Each
     public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> Each(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.EachEntityPointerCallbackPointer).Build();
     }
 
@@ -204,6 +223,7 @@ public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> Each
     public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> Each(delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.EachIterPointerCallbackPointer).Build();
     }
 }
\ No newline at end of file
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/ObserverBuilder/ObserverBuilder.NodeBuilder/T15.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/ObserverBuilder/ObserverBuilder.NodeBuilder/T15.g.cs
index 9adff94a..b1253516 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/ObserverBuilder/ObserverBuilder.NodeBuilder/T15.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/ObserverBuilder/ObserverBuilder.NodeBuilder/T15.g.cs
@@ -14,6 +14,7 @@ public unsafe partial struct ObserverBuilder<T0, T1, T2, T3, T4, T5, T6, T7, T8,
     public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> Run(Ecs.RunCallback callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertSparseTypes(World, true);
         return SetRun(callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.RunCallbackDelegate).Build();
     }
 
@@ -24,6 +25,7 @@ public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>
     public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> Run(delegate*<Iter, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertSparseTypes(World, true);
         return SetRun((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.RunCallbackPointer).Build();
     }
 
@@ -34,6 +36,7 @@ public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>
     public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> Iter(Ecs.IterFieldCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertSparseTypes(World, false);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.IterFieldCallbackDelegate).Build();
     }
 
@@ -44,6 +47,7 @@ public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>
     public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> Iter(Ecs.IterSpanCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertSparseTypes(World, false);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.IterSpanCallbackDelegate).Build();
     }
 
@@ -54,6 +58,7 @@ public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>
     public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> Iter(Ecs.IterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertSparseTypes(World, false);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.IterPointerCallbackDelegate).Build();
     }
 
@@ -64,6 +69,7 @@ public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>
     public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> Iter(delegate*<Iter, Field<T0>, Field<T1>, Field<T2>, Field<T3>, Field<T4>, Field<T5>, Field<T6>, Field<T7>, Field<T8>, Field<T9>, Field<T10>, Field<T11>, Field<T12>, Field<T13>, Field<T14>, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertSparseTypes(World, false);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.IterFieldCallbackPointer).Build();
     }
 
@@ -74,6 +80,7 @@ public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>
     public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> Iter(delegate*<Iter, Span<T0>, Span<T1>, Span<T2>, Span<T3>, Span<T4>, Span<T5>, Span<T6>, Span<T7>, Span<T8>, Span<T9>, Span<T10>, Span<T11>, Span<T12>, Span<T13>, Span<T14>, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertSparseTypes(World, false);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.IterSpanCallbackPointer).Build();
     }
 
@@ -84,6 +91,7 @@ public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>
     public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> Iter(delegate*<Iter, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, T14*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertSparseTypes(World, false);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.IterPointerCallbackPointer).Build();
     }
 
@@ -94,6 +102,7 @@ public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>
     public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> Each(Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.EachRefCallbackDelegate).Build();
     }
 
@@ -104,6 +113,7 @@ public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>
     public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> Each(Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.EachEntityRefCallbackDelegate).Build();
     }
 
@@ -114,6 +124,7 @@ public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>
     public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> Each(Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.EachIterRefCallbackDelegate).Build();
     }
 
@@ -124,6 +135,7 @@ public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>
     public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> Each(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, ref T14, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.EachRefCallbackPointer).Build();
     }
 
@@ -134,6 +146,7 @@ public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>
     public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> Each(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, ref T14, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.EachEntityRefCallbackPointer).Build();
     }
 
@@ -144,6 +157,7 @@ public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>
     public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> Each(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, ref T14, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.EachIterRefCallbackPointer).Build();
     }
 
@@ -154,6 +168,7 @@ public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>
     public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> Each(Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.EachPointerCallbackDelegate).Build();
     }
 
@@ -164,6 +179,7 @@ public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>
     public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> Each(Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.EachEntityPointerCallbackDelegate).Build();
     }
 
@@ -174,6 +190,7 @@ public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>
     public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> Each(Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.EachIterPointerCallbackDelegate).Build();
     }
 
@@ -184,6 +201,7 @@ public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>
     public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> Each(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, T14*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.EachPointerCallbackPointer).Build();
     }
 
@@ -194,6 +212,7 @@ public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>
     public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> Each(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, T14*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.EachEntityPointerCallbackPointer).Build();
     }
 
@@ -204,6 +223,7 @@ public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>
     public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> Each(delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, T14*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.EachIterPointerCallbackPointer).Build();
     }
 }
\ No newline at end of file
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/ObserverBuilder/ObserverBuilder.NodeBuilder/T16.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/ObserverBuilder/ObserverBuilder.NodeBuilder/T16.g.cs
index 549f5cd5..17055e3f 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/ObserverBuilder/ObserverBuilder.NodeBuilder/T16.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/ObserverBuilder/ObserverBuilder.NodeBuilder/T16.g.cs
@@ -14,6 +14,7 @@ public unsafe partial struct ObserverBuilder<T0, T1, T2, T3, T4, T5, T6, T7, T8,
     public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> Run(Ecs.RunCallback callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertSparseTypes(World, true);
         return SetRun(callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.RunCallbackDelegate).Build();
     }
 
@@ -24,6 +25,7 @@ public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
     public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> Run(delegate*<Iter, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertSparseTypes(World, true);
         return SetRun((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.RunCallbackPointer).Build();
     }
 
@@ -34,6 +36,7 @@ public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
     public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> Iter(Ecs.IterFieldCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertSparseTypes(World, false);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.IterFieldCallbackDelegate).Build();
     }
 
@@ -44,6 +47,7 @@ public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
     public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> Iter(Ecs.IterSpanCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertSparseTypes(World, false);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.IterSpanCallbackDelegate).Build();
     }
 
@@ -54,6 +58,7 @@ public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
     public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> Iter(Ecs.IterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertSparseTypes(World, false);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.IterPointerCallbackDelegate).Build();
     }
 
@@ -64,6 +69,7 @@ public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
     public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> Iter(delegate*<Iter, Field<T0>, Field<T1>, Field<T2>, Field<T3>, Field<T4>, Field<T5>, Field<T6>, Field<T7>, Field<T8>, Field<T9>, Field<T10>, Field<T11>, Field<T12>, Field<T13>, Field<T14>, Field<T15>, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertSparseTypes(World, false);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.IterFieldCallbackPointer).Build();
     }
 
@@ -74,6 +80,7 @@ public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
     public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> Iter(delegate*<Iter, Span<T0>, Span<T1>, Span<T2>, Span<T3>, Span<T4>, Span<T5>, Span<T6>, Span<T7>, Span<T8>, Span<T9>, Span<T10>, Span<T11>, Span<T12>, Span<T13>, Span<T14>, Span<T15>, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertSparseTypes(World, false);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.IterSpanCallbackPointer).Build();
     }
 
@@ -84,6 +91,7 @@ public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
     public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> Iter(delegate*<Iter, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, T14*, T15*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertSparseTypes(World, false);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.IterPointerCallbackPointer).Build();
     }
 
@@ -94,6 +102,7 @@ public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
     public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> Each(Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.EachRefCallbackDelegate).Build();
     }
 
@@ -104,6 +113,7 @@ public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
     public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> Each(Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.EachEntityRefCallbackDelegate).Build();
     }
 
@@ -114,6 +124,7 @@ public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
     public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> Each(Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.EachIterRefCallbackDelegate).Build();
     }
 
@@ -124,6 +135,7 @@ public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
     public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> Each(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, ref T14, ref T15, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.EachRefCallbackPointer).Build();
     }
 
@@ -134,6 +146,7 @@ public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
     public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> Each(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, ref T14, ref T15, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.EachEntityRefCallbackPointer).Build();
     }
 
@@ -144,6 +157,7 @@ public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
     public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> Each(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, ref T14, ref T15, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.EachIterRefCallbackPointer).Build();
     }
 
@@ -154,6 +168,7 @@ public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
     public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> Each(Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.EachPointerCallbackDelegate).Build();
     }
 
@@ -164,6 +179,7 @@ public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
     public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> Each(Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.EachEntityPointerCallbackDelegate).Build();
     }
 
@@ -174,6 +190,7 @@ public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
     public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> Each(Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.EachIterPointerCallbackDelegate).Build();
     }
 
@@ -184,6 +201,7 @@ public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
     public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> Each(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, T14*, T15*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.EachPointerCallbackPointer).Build();
     }
 
@@ -194,6 +212,7 @@ public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
     public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> Each(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, T14*, T15*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.EachEntityPointerCallbackPointer).Build();
     }
 
@@ -204,6 +223,7 @@ public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
     public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> Each(delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, T14*, T15*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.EachIterPointerCallbackPointer).Build();
     }
 }
\ No newline at end of file
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/ObserverBuilder/ObserverBuilder.NodeBuilder/T2.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/ObserverBuilder/ObserverBuilder.NodeBuilder/T2.g.cs
index cd9e5257..18beb7a2 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/ObserverBuilder/ObserverBuilder.NodeBuilder/T2.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/ObserverBuilder/ObserverBuilder.NodeBuilder/T2.g.cs
@@ -14,6 +14,7 @@ public unsafe partial struct ObserverBuilder<T0, T1>
     public Observer<T0, T1> Run(Ecs.RunCallback callback)
     {
         TypeHelper<T0, T1>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1>.AssertSparseTypes(World, true);
         return SetRun(callback, Pointers<T0, T1>.RunCallbackDelegate).Build();
     }
 
@@ -24,6 +25,7 @@ public Observer<T0, T1> Run(Ecs.RunCallback callback)
     public Observer<T0, T1> Run(delegate*<Iter, void> callback)
     {
         TypeHelper<T0, T1>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1>.AssertSparseTypes(World, true);
         return SetRun((IntPtr)callback, Pointers<T0, T1>.RunCallbackPointer).Build();
     }
 
@@ -34,6 +36,7 @@ public Observer<T0, T1> Run(delegate*<Iter, void> callback)
     public Observer<T0, T1> Iter(Ecs.IterFieldCallback<T0, T1> callback)
     {
         TypeHelper<T0, T1>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1>.AssertSparseTypes(World, false);
         return SetCallback(callback, Pointers<T0, T1>.IterFieldCallbackDelegate).Build();
     }
 
@@ -44,6 +47,7 @@ public Observer<T0, T1> Iter(Ecs.IterFieldCallback<T0, T1> callback)
     public Observer<T0, T1> Iter(Ecs.IterSpanCallback<T0, T1> callback)
     {
         TypeHelper<T0, T1>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1>.AssertSparseTypes(World, false);
         return SetCallback(callback, Pointers<T0, T1>.IterSpanCallbackDelegate).Build();
     }
 
@@ -54,6 +58,7 @@ public Observer<T0, T1> Iter(Ecs.IterSpanCallback<T0, T1> callback)
     public Observer<T0, T1> Iter(Ecs.IterPointerCallback<T0, T1> callback)
     {
         TypeHelper<T0, T1>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1>.AssertSparseTypes(World, false);
         return SetCallback(callback, Pointers<T0, T1>.IterPointerCallbackDelegate).Build();
     }
 
@@ -64,6 +69,7 @@ public Observer<T0, T1> Iter(Ecs.IterPointerCallback<T0, T1> callback)
     public Observer<T0, T1> Iter(delegate*<Iter, Field<T0>, Field<T1>, void> callback)
     {
         TypeHelper<T0, T1>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1>.AssertSparseTypes(World, false);
         return SetCallback((IntPtr)callback, Pointers<T0, T1>.IterFieldCallbackPointer).Build();
     }
 
@@ -74,6 +80,7 @@ public Observer<T0, T1> Iter(delegate*<Iter, Field<T0>, Field<T1>, void> callbac
     public Observer<T0, T1> Iter(delegate*<Iter, Span<T0>, Span<T1>, void> callback)
     {
         TypeHelper<T0, T1>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1>.AssertSparseTypes(World, false);
         return SetCallback((IntPtr)callback, Pointers<T0, T1>.IterSpanCallbackPointer).Build();
     }
 
@@ -84,6 +91,7 @@ public Observer<T0, T1> Iter(delegate*<Iter, Span<T0>, Span<T1>, void> callback)
     public Observer<T0, T1> Iter(delegate*<Iter, T0*, T1*, void> callback)
     {
         TypeHelper<T0, T1>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1>.AssertSparseTypes(World, false);
         return SetCallback((IntPtr)callback, Pointers<T0, T1>.IterPointerCallbackPointer).Build();
     }
 
@@ -94,6 +102,7 @@ public Observer<T0, T1> Iter(delegate*<Iter, T0*, T1*, void> callback)
     public Observer<T0, T1> Each(Ecs.EachRefCallback<T0, T1> callback)
     {
         TypeHelper<T0, T1>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0, T1>.EachRefCallbackDelegate).Build();
     }
 
@@ -104,6 +113,7 @@ public Observer<T0, T1> Each(Ecs.EachRefCallback<T0, T1> callback)
     public Observer<T0, T1> Each(Ecs.EachEntityRefCallback<T0, T1> callback)
     {
         TypeHelper<T0, T1>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0, T1>.EachEntityRefCallbackDelegate).Build();
     }
 
@@ -114,6 +124,7 @@ public Observer<T0, T1> Each(Ecs.EachEntityRefCallback<T0, T1> callback)
     public Observer<T0, T1> Each(Ecs.EachIterRefCallback<T0, T1> callback)
     {
         TypeHelper<T0, T1>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0, T1>.EachIterRefCallbackDelegate).Build();
     }
 
@@ -124,6 +135,7 @@ public Observer<T0, T1> Each(Ecs.EachIterRefCallback<T0, T1> callback)
     public Observer<T0, T1> Each(delegate*<ref T0, ref T1, void> callback)
     {
         TypeHelper<T0, T1>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0, T1>.EachRefCallbackPointer).Build();
     }
 
@@ -134,6 +146,7 @@ public Observer<T0, T1> Each(delegate*<ref T0, ref T1, void> callback)
     public Observer<T0, T1> Each(delegate*<Entity, ref T0, ref T1, void> callback)
     {
         TypeHelper<T0, T1>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0, T1>.EachEntityRefCallbackPointer).Build();
     }
 
@@ -144,6 +157,7 @@ public Observer<T0, T1> Each(delegate*<Entity, ref T0, ref T1, void> callback)
     public Observer<T0, T1> Each(delegate*<Iter, int, ref T0, ref T1, void> callback)
     {
         TypeHelper<T0, T1>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0, T1>.EachIterRefCallbackPointer).Build();
     }
 
@@ -154,6 +168,7 @@ public Observer<T0, T1> Each(delegate*<Iter, int, ref T0, ref T1, void> callback
     public Observer<T0, T1> Each(Ecs.EachPointerCallback<T0, T1> callback)
     {
         TypeHelper<T0, T1>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0, T1>.EachPointerCallbackDelegate).Build();
     }
 
@@ -164,6 +179,7 @@ public Observer<T0, T1> Each(Ecs.EachPointerCallback<T0, T1> callback)
     public Observer<T0, T1> Each(Ecs.EachEntityPointerCallback<T0, T1> callback)
     {
         TypeHelper<T0, T1>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0, T1>.EachEntityPointerCallbackDelegate).Build();
     }
 
@@ -174,6 +190,7 @@ public Observer<T0, T1> Each(Ecs.EachEntityPointerCallback<T0, T1> callback)
     public Observer<T0, T1> Each(Ecs.EachIterPointerCallback<T0, T1> callback)
     {
         TypeHelper<T0, T1>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0, T1>.EachIterPointerCallbackDelegate).Build();
     }
 
@@ -184,6 +201,7 @@ public Observer<T0, T1> Each(Ecs.EachIterPointerCallback<T0, T1> callback)
     public Observer<T0, T1> Each(delegate*<T0*, T1*, void> callback)
     {
         TypeHelper<T0, T1>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0, T1>.EachPointerCallbackPointer).Build();
     }
 
@@ -194,6 +212,7 @@ public Observer<T0, T1> Each(delegate*<T0*, T1*, void> callback)
     public Observer<T0, T1> Each(delegate*<Entity, T0*, T1*, void> callback)
     {
         TypeHelper<T0, T1>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0, T1>.EachEntityPointerCallbackPointer).Build();
     }
 
@@ -204,6 +223,7 @@ public Observer<T0, T1> Each(delegate*<Entity, T0*, T1*, void> callback)
     public Observer<T0, T1> Each(delegate*<Iter, int, T0*, T1*, void> callback)
     {
         TypeHelper<T0, T1>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0, T1>.EachIterPointerCallbackPointer).Build();
     }
 }
\ No newline at end of file
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/ObserverBuilder/ObserverBuilder.NodeBuilder/T3.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/ObserverBuilder/ObserverBuilder.NodeBuilder/T3.g.cs
index b1915330..10a240d3 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/ObserverBuilder/ObserverBuilder.NodeBuilder/T3.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/ObserverBuilder/ObserverBuilder.NodeBuilder/T3.g.cs
@@ -14,6 +14,7 @@ public unsafe partial struct ObserverBuilder<T0, T1, T2>
     public Observer<T0, T1, T2> Run(Ecs.RunCallback callback)
     {
         TypeHelper<T0, T1, T2>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2>.AssertSparseTypes(World, true);
         return SetRun(callback, Pointers<T0, T1, T2>.RunCallbackDelegate).Build();
     }
 
@@ -24,6 +25,7 @@ public Observer<T0, T1, T2> Run(Ecs.RunCallback callback)
     public Observer<T0, T1, T2> Run(delegate*<Iter, void> callback)
     {
         TypeHelper<T0, T1, T2>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2>.AssertSparseTypes(World, true);
         return SetRun((IntPtr)callback, Pointers<T0, T1, T2>.RunCallbackPointer).Build();
     }
 
@@ -34,6 +36,7 @@ public Observer<T0, T1, T2> Run(delegate*<Iter, void> callback)
     public Observer<T0, T1, T2> Iter(Ecs.IterFieldCallback<T0, T1, T2> callback)
     {
         TypeHelper<T0, T1, T2>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2>.AssertSparseTypes(World, false);
         return SetCallback(callback, Pointers<T0, T1, T2>.IterFieldCallbackDelegate).Build();
     }
 
@@ -44,6 +47,7 @@ public Observer<T0, T1, T2> Iter(Ecs.IterFieldCallback<T0, T1, T2> callback)
     public Observer<T0, T1, T2> Iter(Ecs.IterSpanCallback<T0, T1, T2> callback)
     {
         TypeHelper<T0, T1, T2>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2>.AssertSparseTypes(World, false);
         return SetCallback(callback, Pointers<T0, T1, T2>.IterSpanCallbackDelegate).Build();
     }
 
@@ -54,6 +58,7 @@ public Observer<T0, T1, T2> Iter(Ecs.IterSpanCallback<T0, T1, T2> callback)
     public Observer<T0, T1, T2> Iter(Ecs.IterPointerCallback<T0, T1, T2> callback)
     {
         TypeHelper<T0, T1, T2>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2>.AssertSparseTypes(World, false);
         return SetCallback(callback, Pointers<T0, T1, T2>.IterPointerCallbackDelegate).Build();
     }
 
@@ -64,6 +69,7 @@ public Observer<T0, T1, T2> Iter(Ecs.IterPointerCallback<T0, T1, T2> callback)
     public Observer<T0, T1, T2> Iter(delegate*<Iter, Field<T0>, Field<T1>, Field<T2>, void> callback)
     {
         TypeHelper<T0, T1, T2>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2>.AssertSparseTypes(World, false);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2>.IterFieldCallbackPointer).Build();
     }
 
@@ -74,6 +80,7 @@ public Observer<T0, T1, T2> Iter(delegate*<Iter, Field<T0>, Field<T1>, Field<T2>
     public Observer<T0, T1, T2> Iter(delegate*<Iter, Span<T0>, Span<T1>, Span<T2>, void> callback)
     {
         TypeHelper<T0, T1, T2>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2>.AssertSparseTypes(World, false);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2>.IterSpanCallbackPointer).Build();
     }
 
@@ -84,6 +91,7 @@ public Observer<T0, T1, T2> Iter(delegate*<Iter, Span<T0>, Span<T1>, Span<T2>, v
     public Observer<T0, T1, T2> Iter(delegate*<Iter, T0*, T1*, T2*, void> callback)
     {
         TypeHelper<T0, T1, T2>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2>.AssertSparseTypes(World, false);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2>.IterPointerCallbackPointer).Build();
     }
 
@@ -94,6 +102,7 @@ public Observer<T0, T1, T2> Iter(delegate*<Iter, T0*, T1*, T2*, void> callback)
     public Observer<T0, T1, T2> Each(Ecs.EachRefCallback<T0, T1, T2> callback)
     {
         TypeHelper<T0, T1, T2>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0, T1, T2>.EachRefCallbackDelegate).Build();
     }
 
@@ -104,6 +113,7 @@ public Observer<T0, T1, T2> Each(Ecs.EachRefCallback<T0, T1, T2> callback)
     public Observer<T0, T1, T2> Each(Ecs.EachEntityRefCallback<T0, T1, T2> callback)
     {
         TypeHelper<T0, T1, T2>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0, T1, T2>.EachEntityRefCallbackDelegate).Build();
     }
 
@@ -114,6 +124,7 @@ public Observer<T0, T1, T2> Each(Ecs.EachEntityRefCallback<T0, T1, T2> callback)
     public Observer<T0, T1, T2> Each(Ecs.EachIterRefCallback<T0, T1, T2> callback)
     {
         TypeHelper<T0, T1, T2>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0, T1, T2>.EachIterRefCallbackDelegate).Build();
     }
 
@@ -124,6 +135,7 @@ public Observer<T0, T1, T2> Each(Ecs.EachIterRefCallback<T0, T1, T2> callback)
     public Observer<T0, T1, T2> Each(delegate*<ref T0, ref T1, ref T2, void> callback)
     {
         TypeHelper<T0, T1, T2>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2>.EachRefCallbackPointer).Build();
     }
 
@@ -134,6 +146,7 @@ public Observer<T0, T1, T2> Each(delegate*<ref T0, ref T1, ref T2, void> callbac
     public Observer<T0, T1, T2> Each(delegate*<Entity, ref T0, ref T1, ref T2, void> callback)
     {
         TypeHelper<T0, T1, T2>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2>.EachEntityRefCallbackPointer).Build();
     }
 
@@ -144,6 +157,7 @@ public Observer<T0, T1, T2> Each(delegate*<Entity, ref T0, ref T1, ref T2, void>
     public Observer<T0, T1, T2> Each(delegate*<Iter, int, ref T0, ref T1, ref T2, void> callback)
     {
         TypeHelper<T0, T1, T2>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2>.EachIterRefCallbackPointer).Build();
     }
 
@@ -154,6 +168,7 @@ public Observer<T0, T1, T2> Each(delegate*<Iter, int, ref T0, ref T1, ref T2, vo
     public Observer<T0, T1, T2> Each(Ecs.EachPointerCallback<T0, T1, T2> callback)
     {
         TypeHelper<T0, T1, T2>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0, T1, T2>.EachPointerCallbackDelegate).Build();
     }
 
@@ -164,6 +179,7 @@ public Observer<T0, T1, T2> Each(Ecs.EachPointerCallback<T0, T1, T2> callback)
     public Observer<T0, T1, T2> Each(Ecs.EachEntityPointerCallback<T0, T1, T2> callback)
     {
         TypeHelper<T0, T1, T2>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0, T1, T2>.EachEntityPointerCallbackDelegate).Build();
     }
 
@@ -174,6 +190,7 @@ public Observer<T0, T1, T2> Each(Ecs.EachEntityPointerCallback<T0, T1, T2> callb
     public Observer<T0, T1, T2> Each(Ecs.EachIterPointerCallback<T0, T1, T2> callback)
     {
         TypeHelper<T0, T1, T2>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0, T1, T2>.EachIterPointerCallbackDelegate).Build();
     }
 
@@ -184,6 +201,7 @@ public Observer<T0, T1, T2> Each(Ecs.EachIterPointerCallback<T0, T1, T2> callbac
     public Observer<T0, T1, T2> Each(delegate*<T0*, T1*, T2*, void> callback)
     {
         TypeHelper<T0, T1, T2>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2>.EachPointerCallbackPointer).Build();
     }
 
@@ -194,6 +212,7 @@ public Observer<T0, T1, T2> Each(delegate*<T0*, T1*, T2*, void> callback)
     public Observer<T0, T1, T2> Each(delegate*<Entity, T0*, T1*, T2*, void> callback)
     {
         TypeHelper<T0, T1, T2>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2>.EachEntityPointerCallbackPointer).Build();
     }
 
@@ -204,6 +223,7 @@ public Observer<T0, T1, T2> Each(delegate*<Entity, T0*, T1*, T2*, void> callback
     public Observer<T0, T1, T2> Each(delegate*<Iter, int, T0*, T1*, T2*, void> callback)
     {
         TypeHelper<T0, T1, T2>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2>.EachIterPointerCallbackPointer).Build();
     }
 }
\ No newline at end of file
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/ObserverBuilder/ObserverBuilder.NodeBuilder/T4.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/ObserverBuilder/ObserverBuilder.NodeBuilder/T4.g.cs
index 0fbde475..1668134c 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/ObserverBuilder/ObserverBuilder.NodeBuilder/T4.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/ObserverBuilder/ObserverBuilder.NodeBuilder/T4.g.cs
@@ -14,6 +14,7 @@ public unsafe partial struct ObserverBuilder<T0, T1, T2, T3>
     public Observer<T0, T1, T2, T3> Run(Ecs.RunCallback callback)
     {
         TypeHelper<T0, T1, T2, T3>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3>.AssertSparseTypes(World, true);
         return SetRun(callback, Pointers<T0, T1, T2, T3>.RunCallbackDelegate).Build();
     }
 
@@ -24,6 +25,7 @@ public Observer<T0, T1, T2, T3> Run(Ecs.RunCallback callback)
     public Observer<T0, T1, T2, T3> Run(delegate*<Iter, void> callback)
     {
         TypeHelper<T0, T1, T2, T3>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3>.AssertSparseTypes(World, true);
         return SetRun((IntPtr)callback, Pointers<T0, T1, T2, T3>.RunCallbackPointer).Build();
     }
 
@@ -34,6 +36,7 @@ public Observer<T0, T1, T2, T3> Run(delegate*<Iter, void> callback)
     public Observer<T0, T1, T2, T3> Iter(Ecs.IterFieldCallback<T0, T1, T2, T3> callback)
     {
         TypeHelper<T0, T1, T2, T3>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3>.AssertSparseTypes(World, false);
         return SetCallback(callback, Pointers<T0, T1, T2, T3>.IterFieldCallbackDelegate).Build();
     }
 
@@ -44,6 +47,7 @@ public Observer<T0, T1, T2, T3> Iter(Ecs.IterFieldCallback<T0, T1, T2, T3> callb
     public Observer<T0, T1, T2, T3> Iter(Ecs.IterSpanCallback<T0, T1, T2, T3> callback)
     {
         TypeHelper<T0, T1, T2, T3>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3>.AssertSparseTypes(World, false);
         return SetCallback(callback, Pointers<T0, T1, T2, T3>.IterSpanCallbackDelegate).Build();
     }
 
@@ -54,6 +58,7 @@ public Observer<T0, T1, T2, T3> Iter(Ecs.IterSpanCallback<T0, T1, T2, T3> callba
     public Observer<T0, T1, T2, T3> Iter(Ecs.IterPointerCallback<T0, T1, T2, T3> callback)
     {
         TypeHelper<T0, T1, T2, T3>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3>.AssertSparseTypes(World, false);
         return SetCallback(callback, Pointers<T0, T1, T2, T3>.IterPointerCallbackDelegate).Build();
     }
 
@@ -64,6 +69,7 @@ public Observer<T0, T1, T2, T3> Iter(Ecs.IterPointerCallback<T0, T1, T2, T3> cal
     public Observer<T0, T1, T2, T3> Iter(delegate*<Iter, Field<T0>, Field<T1>, Field<T2>, Field<T3>, void> callback)
     {
         TypeHelper<T0, T1, T2, T3>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3>.AssertSparseTypes(World, false);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3>.IterFieldCallbackPointer).Build();
     }
 
@@ -74,6 +80,7 @@ public Observer<T0, T1, T2, T3> Iter(delegate*<Iter, Field<T0>, Field<T1>, Field
     public Observer<T0, T1, T2, T3> Iter(delegate*<Iter, Span<T0>, Span<T1>, Span<T2>, Span<T3>, void> callback)
     {
         TypeHelper<T0, T1, T2, T3>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3>.AssertSparseTypes(World, false);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3>.IterSpanCallbackPointer).Build();
     }
 
@@ -84,6 +91,7 @@ public Observer<T0, T1, T2, T3> Iter(delegate*<Iter, Span<T0>, Span<T1>, Span<T2
     public Observer<T0, T1, T2, T3> Iter(delegate*<Iter, T0*, T1*, T2*, T3*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3>.AssertSparseTypes(World, false);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3>.IterPointerCallbackPointer).Build();
     }
 
@@ -94,6 +102,7 @@ public Observer<T0, T1, T2, T3> Iter(delegate*<Iter, T0*, T1*, T2*, T3*, void> c
     public Observer<T0, T1, T2, T3> Each(Ecs.EachRefCallback<T0, T1, T2, T3> callback)
     {
         TypeHelper<T0, T1, T2, T3>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0, T1, T2, T3>.EachRefCallbackDelegate).Build();
     }
 
@@ -104,6 +113,7 @@ public Observer<T0, T1, T2, T3> Each(Ecs.EachRefCallback<T0, T1, T2, T3> callbac
     public Observer<T0, T1, T2, T3> Each(Ecs.EachEntityRefCallback<T0, T1, T2, T3> callback)
     {
         TypeHelper<T0, T1, T2, T3>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0, T1, T2, T3>.EachEntityRefCallbackDelegate).Build();
     }
 
@@ -114,6 +124,7 @@ public Observer<T0, T1, T2, T3> Each(Ecs.EachEntityRefCallback<T0, T1, T2, T3> c
     public Observer<T0, T1, T2, T3> Each(Ecs.EachIterRefCallback<T0, T1, T2, T3> callback)
     {
         TypeHelper<T0, T1, T2, T3>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0, T1, T2, T3>.EachIterRefCallbackDelegate).Build();
     }
 
@@ -124,6 +135,7 @@ public Observer<T0, T1, T2, T3> Each(Ecs.EachIterRefCallback<T0, T1, T2, T3> cal
     public Observer<T0, T1, T2, T3> Each(delegate*<ref T0, ref T1, ref T2, ref T3, void> callback)
     {
         TypeHelper<T0, T1, T2, T3>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3>.EachRefCallbackPointer).Build();
     }
 
@@ -134,6 +146,7 @@ public Observer<T0, T1, T2, T3> Each(delegate*<ref T0, ref T1, ref T2, ref T3, v
     public Observer<T0, T1, T2, T3> Each(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, void> callback)
     {
         TypeHelper<T0, T1, T2, T3>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3>.EachEntityRefCallbackPointer).Build();
     }
 
@@ -144,6 +157,7 @@ public Observer<T0, T1, T2, T3> Each(delegate*<Entity, ref T0, ref T1, ref T2, r
     public Observer<T0, T1, T2, T3> Each(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, void> callback)
     {
         TypeHelper<T0, T1, T2, T3>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3>.EachIterRefCallbackPointer).Build();
     }
 
@@ -154,6 +168,7 @@ public Observer<T0, T1, T2, T3> Each(delegate*<Iter, int, ref T0, ref T1, ref T2
     public Observer<T0, T1, T2, T3> Each(Ecs.EachPointerCallback<T0, T1, T2, T3> callback)
     {
         TypeHelper<T0, T1, T2, T3>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0, T1, T2, T3>.EachPointerCallbackDelegate).Build();
     }
 
@@ -164,6 +179,7 @@ public Observer<T0, T1, T2, T3> Each(Ecs.EachPointerCallback<T0, T1, T2, T3> cal
     public Observer<T0, T1, T2, T3> Each(Ecs.EachEntityPointerCallback<T0, T1, T2, T3> callback)
     {
         TypeHelper<T0, T1, T2, T3>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0, T1, T2, T3>.EachEntityPointerCallbackDelegate).Build();
     }
 
@@ -174,6 +190,7 @@ public Observer<T0, T1, T2, T3> Each(Ecs.EachEntityPointerCallback<T0, T1, T2, T
     public Observer<T0, T1, T2, T3> Each(Ecs.EachIterPointerCallback<T0, T1, T2, T3> callback)
     {
         TypeHelper<T0, T1, T2, T3>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0, T1, T2, T3>.EachIterPointerCallbackDelegate).Build();
     }
 
@@ -184,6 +201,7 @@ public Observer<T0, T1, T2, T3> Each(Ecs.EachIterPointerCallback<T0, T1, T2, T3>
     public Observer<T0, T1, T2, T3> Each(delegate*<T0*, T1*, T2*, T3*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3>.EachPointerCallbackPointer).Build();
     }
 
@@ -194,6 +212,7 @@ public Observer<T0, T1, T2, T3> Each(delegate*<T0*, T1*, T2*, T3*, void> callbac
     public Observer<T0, T1, T2, T3> Each(delegate*<Entity, T0*, T1*, T2*, T3*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3>.EachEntityPointerCallbackPointer).Build();
     }
 
@@ -204,6 +223,7 @@ public Observer<T0, T1, T2, T3> Each(delegate*<Entity, T0*, T1*, T2*, T3*, void>
     public Observer<T0, T1, T2, T3> Each(delegate*<Iter, int, T0*, T1*, T2*, T3*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3>.EachIterPointerCallbackPointer).Build();
     }
 }
\ No newline at end of file
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/ObserverBuilder/ObserverBuilder.NodeBuilder/T5.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/ObserverBuilder/ObserverBuilder.NodeBuilder/T5.g.cs
index 59cad492..5bfac7a1 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/ObserverBuilder/ObserverBuilder.NodeBuilder/T5.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/ObserverBuilder/ObserverBuilder.NodeBuilder/T5.g.cs
@@ -14,6 +14,7 @@ public unsafe partial struct ObserverBuilder<T0, T1, T2, T3, T4>
     public Observer<T0, T1, T2, T3, T4> Run(Ecs.RunCallback callback)
     {
         TypeHelper<T0, T1, T2, T3, T4>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4>.AssertSparseTypes(World, true);
         return SetRun(callback, Pointers<T0, T1, T2, T3, T4>.RunCallbackDelegate).Build();
     }
 
@@ -24,6 +25,7 @@ public Observer<T0, T1, T2, T3, T4> Run(Ecs.RunCallback callback)
     public Observer<T0, T1, T2, T3, T4> Run(delegate*<Iter, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4>.AssertSparseTypes(World, true);
         return SetRun((IntPtr)callback, Pointers<T0, T1, T2, T3, T4>.RunCallbackPointer).Build();
     }
 
@@ -34,6 +36,7 @@ public Observer<T0, T1, T2, T3, T4> Run(delegate*<Iter, void> callback)
     public Observer<T0, T1, T2, T3, T4> Iter(Ecs.IterFieldCallback<T0, T1, T2, T3, T4> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4>.AssertSparseTypes(World, false);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4>.IterFieldCallbackDelegate).Build();
     }
 
@@ -44,6 +47,7 @@ public Observer<T0, T1, T2, T3, T4> Iter(Ecs.IterFieldCallback<T0, T1, T2, T3, T
     public Observer<T0, T1, T2, T3, T4> Iter(Ecs.IterSpanCallback<T0, T1, T2, T3, T4> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4>.AssertSparseTypes(World, false);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4>.IterSpanCallbackDelegate).Build();
     }
 
@@ -54,6 +58,7 @@ public Observer<T0, T1, T2, T3, T4> Iter(Ecs.IterSpanCallback<T0, T1, T2, T3, T4
     public Observer<T0, T1, T2, T3, T4> Iter(Ecs.IterPointerCallback<T0, T1, T2, T3, T4> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4>.AssertSparseTypes(World, false);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4>.IterPointerCallbackDelegate).Build();
     }
 
@@ -64,6 +69,7 @@ public Observer<T0, T1, T2, T3, T4> Iter(Ecs.IterPointerCallback<T0, T1, T2, T3,
     public Observer<T0, T1, T2, T3, T4> Iter(delegate*<Iter, Field<T0>, Field<T1>, Field<T2>, Field<T3>, Field<T4>, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4>.AssertSparseTypes(World, false);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4>.IterFieldCallbackPointer).Build();
     }
 
@@ -74,6 +80,7 @@ public Observer<T0, T1, T2, T3, T4> Iter(delegate*<Iter, Field<T0>, Field<T1>, F
     public Observer<T0, T1, T2, T3, T4> Iter(delegate*<Iter, Span<T0>, Span<T1>, Span<T2>, Span<T3>, Span<T4>, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4>.AssertSparseTypes(World, false);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4>.IterSpanCallbackPointer).Build();
     }
 
@@ -84,6 +91,7 @@ public Observer<T0, T1, T2, T3, T4> Iter(delegate*<Iter, Span<T0>, Span<T1>, Spa
     public Observer<T0, T1, T2, T3, T4> Iter(delegate*<Iter, T0*, T1*, T2*, T3*, T4*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4>.AssertSparseTypes(World, false);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4>.IterPointerCallbackPointer).Build();
     }
 
@@ -94,6 +102,7 @@ public Observer<T0, T1, T2, T3, T4> Iter(delegate*<Iter, T0*, T1*, T2*, T3*, T4*
     public Observer<T0, T1, T2, T3, T4> Each(Ecs.EachRefCallback<T0, T1, T2, T3, T4> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4>.EachRefCallbackDelegate).Build();
     }
 
@@ -104,6 +113,7 @@ public Observer<T0, T1, T2, T3, T4> Each(Ecs.EachRefCallback<T0, T1, T2, T3, T4>
     public Observer<T0, T1, T2, T3, T4> Each(Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4>.EachEntityRefCallbackDelegate).Build();
     }
 
@@ -114,6 +124,7 @@ public Observer<T0, T1, T2, T3, T4> Each(Ecs.EachEntityRefCallback<T0, T1, T2, T
     public Observer<T0, T1, T2, T3, T4> Each(Ecs.EachIterRefCallback<T0, T1, T2, T3, T4> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4>.EachIterRefCallbackDelegate).Build();
     }
 
@@ -124,6 +135,7 @@ public Observer<T0, T1, T2, T3, T4> Each(Ecs.EachIterRefCallback<T0, T1, T2, T3,
     public Observer<T0, T1, T2, T3, T4> Each(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4>.EachRefCallbackPointer).Build();
     }
 
@@ -134,6 +146,7 @@ public Observer<T0, T1, T2, T3, T4> Each(delegate*<ref T0, ref T1, ref T2, ref T
     public Observer<T0, T1, T2, T3, T4> Each(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4>.EachEntityRefCallbackPointer).Build();
     }
 
@@ -144,6 +157,7 @@ public Observer<T0, T1, T2, T3, T4> Each(delegate*<Entity, ref T0, ref T1, ref T
     public Observer<T0, T1, T2, T3, T4> Each(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4>.EachIterRefCallbackPointer).Build();
     }
 
@@ -154,6 +168,7 @@ public Observer<T0, T1, T2, T3, T4> Each(delegate*<Iter, int, ref T0, ref T1, re
     public Observer<T0, T1, T2, T3, T4> Each(Ecs.EachPointerCallback<T0, T1, T2, T3, T4> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4>.EachPointerCallbackDelegate).Build();
     }
 
@@ -164,6 +179,7 @@ public Observer<T0, T1, T2, T3, T4> Each(Ecs.EachPointerCallback<T0, T1, T2, T3,
     public Observer<T0, T1, T2, T3, T4> Each(Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4>.EachEntityPointerCallbackDelegate).Build();
     }
 
@@ -174,6 +190,7 @@ public Observer<T0, T1, T2, T3, T4> Each(Ecs.EachEntityPointerCallback<T0, T1, T
     public Observer<T0, T1, T2, T3, T4> Each(Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4>.EachIterPointerCallbackDelegate).Build();
     }
 
@@ -184,6 +201,7 @@ public Observer<T0, T1, T2, T3, T4> Each(Ecs.EachIterPointerCallback<T0, T1, T2,
     public Observer<T0, T1, T2, T3, T4> Each(delegate*<T0*, T1*, T2*, T3*, T4*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4>.EachPointerCallbackPointer).Build();
     }
 
@@ -194,6 +212,7 @@ public Observer<T0, T1, T2, T3, T4> Each(delegate*<T0*, T1*, T2*, T3*, T4*, void
     public Observer<T0, T1, T2, T3, T4> Each(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4>.EachEntityPointerCallbackPointer).Build();
     }
 
@@ -204,6 +223,7 @@ public Observer<T0, T1, T2, T3, T4> Each(delegate*<Entity, T0*, T1*, T2*, T3*, T
     public Observer<T0, T1, T2, T3, T4> Each(delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4>.EachIterPointerCallbackPointer).Build();
     }
 }
\ No newline at end of file
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/ObserverBuilder/ObserverBuilder.NodeBuilder/T6.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/ObserverBuilder/ObserverBuilder.NodeBuilder/T6.g.cs
index 4fd082c0..5cbcff22 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/ObserverBuilder/ObserverBuilder.NodeBuilder/T6.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/ObserverBuilder/ObserverBuilder.NodeBuilder/T6.g.cs
@@ -14,6 +14,7 @@ public unsafe partial struct ObserverBuilder<T0, T1, T2, T3, T4, T5>
     public Observer<T0, T1, T2, T3, T4, T5> Run(Ecs.RunCallback callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5>.AssertSparseTypes(World, true);
         return SetRun(callback, Pointers<T0, T1, T2, T3, T4, T5>.RunCallbackDelegate).Build();
     }
 
@@ -24,6 +25,7 @@ public Observer<T0, T1, T2, T3, T4, T5> Run(Ecs.RunCallback callback)
     public Observer<T0, T1, T2, T3, T4, T5> Run(delegate*<Iter, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5>.AssertSparseTypes(World, true);
         return SetRun((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5>.RunCallbackPointer).Build();
     }
 
@@ -34,6 +36,7 @@ public Observer<T0, T1, T2, T3, T4, T5> Run(delegate*<Iter, void> callback)
     public Observer<T0, T1, T2, T3, T4, T5> Iter(Ecs.IterFieldCallback<T0, T1, T2, T3, T4, T5> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5>.AssertSparseTypes(World, false);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5>.IterFieldCallbackDelegate).Build();
     }
 
@@ -44,6 +47,7 @@ public Observer<T0, T1, T2, T3, T4, T5> Iter(Ecs.IterFieldCallback<T0, T1, T2, T
     public Observer<T0, T1, T2, T3, T4, T5> Iter(Ecs.IterSpanCallback<T0, T1, T2, T3, T4, T5> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5>.AssertSparseTypes(World, false);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5>.IterSpanCallbackDelegate).Build();
     }
 
@@ -54,6 +58,7 @@ public Observer<T0, T1, T2, T3, T4, T5> Iter(Ecs.IterSpanCallback<T0, T1, T2, T3
     public Observer<T0, T1, T2, T3, T4, T5> Iter(Ecs.IterPointerCallback<T0, T1, T2, T3, T4, T5> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5>.AssertSparseTypes(World, false);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5>.IterPointerCallbackDelegate).Build();
     }
 
@@ -64,6 +69,7 @@ public Observer<T0, T1, T2, T3, T4, T5> Iter(Ecs.IterPointerCallback<T0, T1, T2,
     public Observer<T0, T1, T2, T3, T4, T5> Iter(delegate*<Iter, Field<T0>, Field<T1>, Field<T2>, Field<T3>, Field<T4>, Field<T5>, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5>.AssertSparseTypes(World, false);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5>.IterFieldCallbackPointer).Build();
     }
 
@@ -74,6 +80,7 @@ public Observer<T0, T1, T2, T3, T4, T5> Iter(delegate*<Iter, Field<T0>, Field<T1
     public Observer<T0, T1, T2, T3, T4, T5> Iter(delegate*<Iter, Span<T0>, Span<T1>, Span<T2>, Span<T3>, Span<T4>, Span<T5>, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5>.AssertSparseTypes(World, false);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5>.IterSpanCallbackPointer).Build();
     }
 
@@ -84,6 +91,7 @@ public Observer<T0, T1, T2, T3, T4, T5> Iter(delegate*<Iter, Span<T0>, Span<T1>,
     public Observer<T0, T1, T2, T3, T4, T5> Iter(delegate*<Iter, T0*, T1*, T2*, T3*, T4*, T5*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5>.AssertSparseTypes(World, false);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5>.IterPointerCallbackPointer).Build();
     }
 
@@ -94,6 +102,7 @@ public Observer<T0, T1, T2, T3, T4, T5> Iter(delegate*<Iter, T0*, T1*, T2*, T3*,
     public Observer<T0, T1, T2, T3, T4, T5> Each(Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5>.EachRefCallbackDelegate).Build();
     }
 
@@ -104,6 +113,7 @@ public Observer<T0, T1, T2, T3, T4, T5> Each(Ecs.EachRefCallback<T0, T1, T2, T3,
     public Observer<T0, T1, T2, T3, T4, T5> Each(Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5>.EachEntityRefCallbackDelegate).Build();
     }
 
@@ -114,6 +124,7 @@ public Observer<T0, T1, T2, T3, T4, T5> Each(Ecs.EachEntityRefCallback<T0, T1, T
     public Observer<T0, T1, T2, T3, T4, T5> Each(Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5>.EachIterRefCallbackDelegate).Build();
     }
 
@@ -124,6 +135,7 @@ public Observer<T0, T1, T2, T3, T4, T5> Each(Ecs.EachIterRefCallback<T0, T1, T2,
     public Observer<T0, T1, T2, T3, T4, T5> Each(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5>.EachRefCallbackPointer).Build();
     }
 
@@ -134,6 +146,7 @@ public Observer<T0, T1, T2, T3, T4, T5> Each(delegate*<ref T0, ref T1, ref T2, r
     public Observer<T0, T1, T2, T3, T4, T5> Each(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5>.EachEntityRefCallbackPointer).Build();
     }
 
@@ -144,6 +157,7 @@ public Observer<T0, T1, T2, T3, T4, T5> Each(delegate*<Entity, ref T0, ref T1, r
     public Observer<T0, T1, T2, T3, T4, T5> Each(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5>.EachIterRefCallbackPointer).Build();
     }
 
@@ -154,6 +168,7 @@ public Observer<T0, T1, T2, T3, T4, T5> Each(delegate*<Iter, int, ref T0, ref T1
     public Observer<T0, T1, T2, T3, T4, T5> Each(Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5>.EachPointerCallbackDelegate).Build();
     }
 
@@ -164,6 +179,7 @@ public Observer<T0, T1, T2, T3, T4, T5> Each(Ecs.EachPointerCallback<T0, T1, T2,
     public Observer<T0, T1, T2, T3, T4, T5> Each(Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5>.EachEntityPointerCallbackDelegate).Build();
     }
 
@@ -174,6 +190,7 @@ public Observer<T0, T1, T2, T3, T4, T5> Each(Ecs.EachEntityPointerCallback<T0, T
     public Observer<T0, T1, T2, T3, T4, T5> Each(Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5>.EachIterPointerCallbackDelegate).Build();
     }
 
@@ -184,6 +201,7 @@ public Observer<T0, T1, T2, T3, T4, T5> Each(Ecs.EachIterPointerCallback<T0, T1,
     public Observer<T0, T1, T2, T3, T4, T5> Each(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5>.EachPointerCallbackPointer).Build();
     }
 
@@ -194,6 +212,7 @@ public Observer<T0, T1, T2, T3, T4, T5> Each(delegate*<T0*, T1*, T2*, T3*, T4*,
     public Observer<T0, T1, T2, T3, T4, T5> Each(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5>.EachEntityPointerCallbackPointer).Build();
     }
 
@@ -204,6 +223,7 @@ public Observer<T0, T1, T2, T3, T4, T5> Each(delegate*<Entity, T0*, T1*, T2*, T3
     public Observer<T0, T1, T2, T3, T4, T5> Each(delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5>.EachIterPointerCallbackPointer).Build();
     }
 }
\ No newline at end of file
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/ObserverBuilder/ObserverBuilder.NodeBuilder/T7.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/ObserverBuilder/ObserverBuilder.NodeBuilder/T7.g.cs
index 7089c5e2..617ce75a 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/ObserverBuilder/ObserverBuilder.NodeBuilder/T7.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/ObserverBuilder/ObserverBuilder.NodeBuilder/T7.g.cs
@@ -14,6 +14,7 @@ public unsafe partial struct ObserverBuilder<T0, T1, T2, T3, T4, T5, T6>
     public Observer<T0, T1, T2, T3, T4, T5, T6> Run(Ecs.RunCallback callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertSparseTypes(World, true);
         return SetRun(callback, Pointers<T0, T1, T2, T3, T4, T5, T6>.RunCallbackDelegate).Build();
     }
 
@@ -24,6 +25,7 @@ public Observer<T0, T1, T2, T3, T4, T5, T6> Run(Ecs.RunCallback callback)
     public Observer<T0, T1, T2, T3, T4, T5, T6> Run(delegate*<Iter, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertSparseTypes(World, true);
         return SetRun((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6>.RunCallbackPointer).Build();
     }
 
@@ -34,6 +36,7 @@ public Observer<T0, T1, T2, T3, T4, T5, T6> Run(delegate*<Iter, void> callback)
     public Observer<T0, T1, T2, T3, T4, T5, T6> Iter(Ecs.IterFieldCallback<T0, T1, T2, T3, T4, T5, T6> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertSparseTypes(World, false);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5, T6>.IterFieldCallbackDelegate).Build();
     }
 
@@ -44,6 +47,7 @@ public Observer<T0, T1, T2, T3, T4, T5, T6> Iter(Ecs.IterFieldCallback<T0, T1, T
     public Observer<T0, T1, T2, T3, T4, T5, T6> Iter(Ecs.IterSpanCallback<T0, T1, T2, T3, T4, T5, T6> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertSparseTypes(World, false);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5, T6>.IterSpanCallbackDelegate).Build();
     }
 
@@ -54,6 +58,7 @@ public Observer<T0, T1, T2, T3, T4, T5, T6> Iter(Ecs.IterSpanCallback<T0, T1, T2
     public Observer<T0, T1, T2, T3, T4, T5, T6> Iter(Ecs.IterPointerCallback<T0, T1, T2, T3, T4, T5, T6> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertSparseTypes(World, false);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5, T6>.IterPointerCallbackDelegate).Build();
     }
 
@@ -64,6 +69,7 @@ public Observer<T0, T1, T2, T3, T4, T5, T6> Iter(Ecs.IterPointerCallback<T0, T1,
     public Observer<T0, T1, T2, T3, T4, T5, T6> Iter(delegate*<Iter, Field<T0>, Field<T1>, Field<T2>, Field<T3>, Field<T4>, Field<T5>, Field<T6>, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertSparseTypes(World, false);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6>.IterFieldCallbackPointer).Build();
     }
 
@@ -74,6 +80,7 @@ public Observer<T0, T1, T2, T3, T4, T5, T6> Iter(delegate*<Iter, Field<T0>, Fiel
     public Observer<T0, T1, T2, T3, T4, T5, T6> Iter(delegate*<Iter, Span<T0>, Span<T1>, Span<T2>, Span<T3>, Span<T4>, Span<T5>, Span<T6>, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertSparseTypes(World, false);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6>.IterSpanCallbackPointer).Build();
     }
 
@@ -84,6 +91,7 @@ public Observer<T0, T1, T2, T3, T4, T5, T6> Iter(delegate*<Iter, Span<T0>, Span<
     public Observer<T0, T1, T2, T3, T4, T5, T6> Iter(delegate*<Iter, T0*, T1*, T2*, T3*, T4*, T5*, T6*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertSparseTypes(World, false);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6>.IterPointerCallbackPointer).Build();
     }
 
@@ -94,6 +102,7 @@ public Observer<T0, T1, T2, T3, T4, T5, T6> Iter(delegate*<Iter, T0*, T1*, T2*,
     public Observer<T0, T1, T2, T3, T4, T5, T6> Each(Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5, T6> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5, T6>.EachRefCallbackDelegate).Build();
     }
 
@@ -104,6 +113,7 @@ public Observer<T0, T1, T2, T3, T4, T5, T6> Each(Ecs.EachRefCallback<T0, T1, T2,
     public Observer<T0, T1, T2, T3, T4, T5, T6> Each(Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5, T6> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5, T6>.EachEntityRefCallbackDelegate).Build();
     }
 
@@ -114,6 +124,7 @@ public Observer<T0, T1, T2, T3, T4, T5, T6> Each(Ecs.EachEntityRefCallback<T0, T
     public Observer<T0, T1, T2, T3, T4, T5, T6> Each(Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5, T6> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5, T6>.EachIterRefCallbackDelegate).Build();
     }
 
@@ -124,6 +135,7 @@ public Observer<T0, T1, T2, T3, T4, T5, T6> Each(Ecs.EachIterRefCallback<T0, T1,
     public Observer<T0, T1, T2, T3, T4, T5, T6> Each(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6>.EachRefCallbackPointer).Build();
     }
 
@@ -134,6 +146,7 @@ public Observer<T0, T1, T2, T3, T4, T5, T6> Each(delegate*<ref T0, ref T1, ref T
     public Observer<T0, T1, T2, T3, T4, T5, T6> Each(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6>.EachEntityRefCallbackPointer).Build();
     }
 
@@ -144,6 +157,7 @@ public Observer<T0, T1, T2, T3, T4, T5, T6> Each(delegate*<Entity, ref T0, ref T
     public Observer<T0, T1, T2, T3, T4, T5, T6> Each(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6>.EachIterRefCallbackPointer).Build();
     }
 
@@ -154,6 +168,7 @@ public Observer<T0, T1, T2, T3, T4, T5, T6> Each(delegate*<Iter, int, ref T0, re
     public Observer<T0, T1, T2, T3, T4, T5, T6> Each(Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5, T6> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5, T6>.EachPointerCallbackDelegate).Build();
     }
 
@@ -164,6 +179,7 @@ public Observer<T0, T1, T2, T3, T4, T5, T6> Each(Ecs.EachPointerCallback<T0, T1,
     public Observer<T0, T1, T2, T3, T4, T5, T6> Each(Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5, T6>.EachEntityPointerCallbackDelegate).Build();
     }
 
@@ -174,6 +190,7 @@ public Observer<T0, T1, T2, T3, T4, T5, T6> Each(Ecs.EachEntityPointerCallback<T
     public Observer<T0, T1, T2, T3, T4, T5, T6> Each(Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5, T6> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5, T6>.EachIterPointerCallbackDelegate).Build();
     }
 
@@ -184,6 +201,7 @@ public Observer<T0, T1, T2, T3, T4, T5, T6> Each(Ecs.EachIterPointerCallback<T0,
     public Observer<T0, T1, T2, T3, T4, T5, T6> Each(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6>.EachPointerCallbackPointer).Build();
     }
 
@@ -194,6 +212,7 @@ public Observer<T0, T1, T2, T3, T4, T5, T6> Each(delegate*<T0*, T1*, T2*, T3*, T
     public Observer<T0, T1, T2, T3, T4, T5, T6> Each(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6>.EachEntityPointerCallbackPointer).Build();
     }
 
@@ -204,6 +223,7 @@ public Observer<T0, T1, T2, T3, T4, T5, T6> Each(delegate*<Entity, T0*, T1*, T2*
     public Observer<T0, T1, T2, T3, T4, T5, T6> Each(delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6>.EachIterPointerCallbackPointer).Build();
     }
 }
\ No newline at end of file
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/ObserverBuilder/ObserverBuilder.NodeBuilder/T8.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/ObserverBuilder/ObserverBuilder.NodeBuilder/T8.g.cs
index 69f1a32b..81b4db05 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/ObserverBuilder/ObserverBuilder.NodeBuilder/T8.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/ObserverBuilder/ObserverBuilder.NodeBuilder/T8.g.cs
@@ -14,6 +14,7 @@ public unsafe partial struct ObserverBuilder<T0, T1, T2, T3, T4, T5, T6, T7>
     public Observer<T0, T1, T2, T3, T4, T5, T6, T7> Run(Ecs.RunCallback callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertSparseTypes(World, true);
         return SetRun(callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7>.RunCallbackDelegate).Build();
     }
 
@@ -24,6 +25,7 @@ public Observer<T0, T1, T2, T3, T4, T5, T6, T7> Run(Ecs.RunCallback callback)
     public Observer<T0, T1, T2, T3, T4, T5, T6, T7> Run(delegate*<Iter, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertSparseTypes(World, true);
         return SetRun((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7>.RunCallbackPointer).Build();
     }
 
@@ -34,6 +36,7 @@ public Observer<T0, T1, T2, T3, T4, T5, T6, T7> Run(delegate*<Iter, void> callba
     public Observer<T0, T1, T2, T3, T4, T5, T6, T7> Iter(Ecs.IterFieldCallback<T0, T1, T2, T3, T4, T5, T6, T7> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertSparseTypes(World, false);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7>.IterFieldCallbackDelegate).Build();
     }
 
@@ -44,6 +47,7 @@ public Observer<T0, T1, T2, T3, T4, T5, T6, T7> Iter(Ecs.IterFieldCallback<T0, T
     public Observer<T0, T1, T2, T3, T4, T5, T6, T7> Iter(Ecs.IterSpanCallback<T0, T1, T2, T3, T4, T5, T6, T7> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertSparseTypes(World, false);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7>.IterSpanCallbackDelegate).Build();
     }
 
@@ -54,6 +58,7 @@ public Observer<T0, T1, T2, T3, T4, T5, T6, T7> Iter(Ecs.IterSpanCallback<T0, T1
     public Observer<T0, T1, T2, T3, T4, T5, T6, T7> Iter(Ecs.IterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertSparseTypes(World, false);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7>.IterPointerCallbackDelegate).Build();
     }
 
@@ -64,6 +69,7 @@ public Observer<T0, T1, T2, T3, T4, T5, T6, T7> Iter(Ecs.IterPointerCallback<T0,
     public Observer<T0, T1, T2, T3, T4, T5, T6, T7> Iter(delegate*<Iter, Field<T0>, Field<T1>, Field<T2>, Field<T3>, Field<T4>, Field<T5>, Field<T6>, Field<T7>, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertSparseTypes(World, false);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7>.IterFieldCallbackPointer).Build();
     }
 
@@ -74,6 +80,7 @@ public Observer<T0, T1, T2, T3, T4, T5, T6, T7> Iter(delegate*<Iter, Field<T0>,
     public Observer<T0, T1, T2, T3, T4, T5, T6, T7> Iter(delegate*<Iter, Span<T0>, Span<T1>, Span<T2>, Span<T3>, Span<T4>, Span<T5>, Span<T6>, Span<T7>, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertSparseTypes(World, false);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7>.IterSpanCallbackPointer).Build();
     }
 
@@ -84,6 +91,7 @@ public Observer<T0, T1, T2, T3, T4, T5, T6, T7> Iter(delegate*<Iter, Span<T0>, S
     public Observer<T0, T1, T2, T3, T4, T5, T6, T7> Iter(delegate*<Iter, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertSparseTypes(World, false);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7>.IterPointerCallbackPointer).Build();
     }
 
@@ -94,6 +102,7 @@ public Observer<T0, T1, T2, T3, T4, T5, T6, T7> Iter(delegate*<Iter, T0*, T1*, T
     public Observer<T0, T1, T2, T3, T4, T5, T6, T7> Each(Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5, T6, T7> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7>.EachRefCallbackDelegate).Build();
     }
 
@@ -104,6 +113,7 @@ public Observer<T0, T1, T2, T3, T4, T5, T6, T7> Each(Ecs.EachRefCallback<T0, T1,
     public Observer<T0, T1, T2, T3, T4, T5, T6, T7> Each(Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7>.EachEntityRefCallbackDelegate).Build();
     }
 
@@ -114,6 +124,7 @@ public Observer<T0, T1, T2, T3, T4, T5, T6, T7> Each(Ecs.EachEntityRefCallback<T
     public Observer<T0, T1, T2, T3, T4, T5, T6, T7> Each(Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7>.EachIterRefCallbackDelegate).Build();
     }
 
@@ -124,6 +135,7 @@ public Observer<T0, T1, T2, T3, T4, T5, T6, T7> Each(Ecs.EachIterRefCallback<T0,
     public Observer<T0, T1, T2, T3, T4, T5, T6, T7> Each(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7>.EachRefCallbackPointer).Build();
     }
 
@@ -134,6 +146,7 @@ public Observer<T0, T1, T2, T3, T4, T5, T6, T7> Each(delegate*<ref T0, ref T1, r
     public Observer<T0, T1, T2, T3, T4, T5, T6, T7> Each(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7>.EachEntityRefCallbackPointer).Build();
     }
 
@@ -144,6 +157,7 @@ public Observer<T0, T1, T2, T3, T4, T5, T6, T7> Each(delegate*<Entity, ref T0, r
     public Observer<T0, T1, T2, T3, T4, T5, T6, T7> Each(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7>.EachIterRefCallbackPointer).Build();
     }
 
@@ -154,6 +168,7 @@ public Observer<T0, T1, T2, T3, T4, T5, T6, T7> Each(delegate*<Iter, int, ref T0
     public Observer<T0, T1, T2, T3, T4, T5, T6, T7> Each(Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7>.EachPointerCallbackDelegate).Build();
     }
 
@@ -164,6 +179,7 @@ public Observer<T0, T1, T2, T3, T4, T5, T6, T7> Each(Ecs.EachPointerCallback<T0,
     public Observer<T0, T1, T2, T3, T4, T5, T6, T7> Each(Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7>.EachEntityPointerCallbackDelegate).Build();
     }
 
@@ -174,6 +190,7 @@ public Observer<T0, T1, T2, T3, T4, T5, T6, T7> Each(Ecs.EachEntityPointerCallba
     public Observer<T0, T1, T2, T3, T4, T5, T6, T7> Each(Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7>.EachIterPointerCallbackDelegate).Build();
     }
 
@@ -184,6 +201,7 @@ public Observer<T0, T1, T2, T3, T4, T5, T6, T7> Each(Ecs.EachIterPointerCallback
     public Observer<T0, T1, T2, T3, T4, T5, T6, T7> Each(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7>.EachPointerCallbackPointer).Build();
     }
 
@@ -194,6 +212,7 @@ public Observer<T0, T1, T2, T3, T4, T5, T6, T7> Each(delegate*<T0*, T1*, T2*, T3
     public Observer<T0, T1, T2, T3, T4, T5, T6, T7> Each(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7>.EachEntityPointerCallbackPointer).Build();
     }
 
@@ -204,6 +223,7 @@ public Observer<T0, T1, T2, T3, T4, T5, T6, T7> Each(delegate*<Entity, T0*, T1*,
     public Observer<T0, T1, T2, T3, T4, T5, T6, T7> Each(delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7>.EachIterPointerCallbackPointer).Build();
     }
 }
\ No newline at end of file
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/ObserverBuilder/ObserverBuilder.NodeBuilder/T9.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/ObserverBuilder/ObserverBuilder.NodeBuilder/T9.g.cs
index 6fb446d3..964afa06 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/ObserverBuilder/ObserverBuilder.NodeBuilder/T9.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/ObserverBuilder/ObserverBuilder.NodeBuilder/T9.g.cs
@@ -14,6 +14,7 @@ public unsafe partial struct ObserverBuilder<T0, T1, T2, T3, T4, T5, T6, T7, T8>
     public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8> Run(Ecs.RunCallback callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertSparseTypes(World, true);
         return SetRun(callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8>.RunCallbackDelegate).Build();
     }
 
@@ -24,6 +25,7 @@ public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8> Run(Ecs.RunCallback callback
     public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8> Run(delegate*<Iter, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertSparseTypes(World, true);
         return SetRun((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8>.RunCallbackPointer).Build();
     }
 
@@ -34,6 +36,7 @@ public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8> Run(delegate*<Iter, void> ca
     public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8> Iter(Ecs.IterFieldCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertSparseTypes(World, false);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8>.IterFieldCallbackDelegate).Build();
     }
 
@@ -44,6 +47,7 @@ public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8> Iter(Ecs.IterFieldCallback<T
     public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8> Iter(Ecs.IterSpanCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertSparseTypes(World, false);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8>.IterSpanCallbackDelegate).Build();
     }
 
@@ -54,6 +58,7 @@ public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8> Iter(Ecs.IterSpanCallback<T0
     public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8> Iter(Ecs.IterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertSparseTypes(World, false);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8>.IterPointerCallbackDelegate).Build();
     }
 
@@ -64,6 +69,7 @@ public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8> Iter(Ecs.IterPointerCallback
     public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8> Iter(delegate*<Iter, Field<T0>, Field<T1>, Field<T2>, Field<T3>, Field<T4>, Field<T5>, Field<T6>, Field<T7>, Field<T8>, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertSparseTypes(World, false);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8>.IterFieldCallbackPointer).Build();
     }
 
@@ -74,6 +80,7 @@ public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8> Iter(delegate*<Iter, Field<T
     public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8> Iter(delegate*<Iter, Span<T0>, Span<T1>, Span<T2>, Span<T3>, Span<T4>, Span<T5>, Span<T6>, Span<T7>, Span<T8>, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertSparseTypes(World, false);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8>.IterSpanCallbackPointer).Build();
     }
 
@@ -84,6 +91,7 @@ public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8> Iter(delegate*<Iter, Span<T0
     public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8> Iter(delegate*<Iter, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertSparseTypes(World, false);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8>.IterPointerCallbackPointer).Build();
     }
 
@@ -94,6 +102,7 @@ public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8> Iter(delegate*<Iter, T0*, T1
     public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8> Each(Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8>.EachRefCallbackDelegate).Build();
     }
 
@@ -104,6 +113,7 @@ public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8> Each(Ecs.EachRefCallback<T0,
     public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8> Each(Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8>.EachEntityRefCallbackDelegate).Build();
     }
 
@@ -114,6 +124,7 @@ public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8> Each(Ecs.EachEntityRefCallba
     public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8> Each(Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8>.EachIterRefCallbackDelegate).Build();
     }
 
@@ -124,6 +135,7 @@ public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8> Each(Ecs.EachIterRefCallback
     public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8> Each(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8>.EachRefCallbackPointer).Build();
     }
 
@@ -134,6 +146,7 @@ public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8> Each(delegate*<ref T0, ref T
     public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8> Each(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8>.EachEntityRefCallbackPointer).Build();
     }
 
@@ -144,6 +157,7 @@ public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8> Each(delegate*<Entity, ref T
     public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8> Each(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8>.EachIterRefCallbackPointer).Build();
     }
 
@@ -154,6 +168,7 @@ public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8> Each(delegate*<Iter, int, re
     public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8> Each(Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8>.EachPointerCallbackDelegate).Build();
     }
 
@@ -164,6 +179,7 @@ public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8> Each(Ecs.EachPointerCallback
     public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8> Each(Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8>.EachEntityPointerCallbackDelegate).Build();
     }
 
@@ -174,6 +190,7 @@ public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8> Each(Ecs.EachEntityPointerCa
     public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8> Each(Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8>.EachIterPointerCallbackDelegate).Build();
     }
 
@@ -184,6 +201,7 @@ public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8> Each(Ecs.EachIterPointerCall
     public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8> Each(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8>.EachPointerCallbackPointer).Build();
     }
 
@@ -194,6 +212,7 @@ public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8> Each(delegate*<T0*, T1*, T2*
     public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8> Each(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8>.EachEntityPointerCallbackPointer).Build();
     }
 
@@ -204,6 +223,7 @@ public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8> Each(delegate*<Entity, T0*,
     public Observer<T0, T1, T2, T3, T4, T5, T6, T7, T8> Each(delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8>.EachIterPointerCallbackPointer).Build();
     }
 }
\ No newline at end of file
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/PageIterable/PageIterable.IIterable/T1.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/PageIterable/PageIterable.IIterable/T1.g.cs
index 8904dbdb..3dc6ffde 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/PageIterable/PageIterable.IIterable/T1.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/PageIterable/PageIterable.IIterable/T1.g.cs
@@ -13,6 +13,7 @@ public unsafe partial struct PageIterable<T0>
     public void Run(Ecs.RunCallback callback)
     {
         TypeHelper<T0>.AssertReferenceTypes(true);
+        TypeHelper<T0>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Run(ref this, callback);
     }
 
@@ -23,6 +24,7 @@ public void Run(Ecs.RunCallback callback)
     public void Run(delegate*<Iter, void> callback)
     {
         TypeHelper<T0>.AssertReferenceTypes(true);
+        TypeHelper<T0>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Run(ref this, callback);
     }
 
@@ -33,6 +35,7 @@ public void Run(delegate*<Iter, void> callback)
     public void Iter(Ecs.IterFieldCallback<T0> callback)
     {
         TypeHelper<T0>.AssertReferenceTypes(true);
+        TypeHelper<T0>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -43,6 +46,7 @@ public void Iter(Ecs.IterFieldCallback<T0> callback)
     public void Iter(Ecs.IterSpanCallback<T0> callback)
     {
         TypeHelper<T0>.AssertReferenceTypes(false);
+        TypeHelper<T0>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -53,6 +57,7 @@ public void Iter(Ecs.IterSpanCallback<T0> callback)
     public void Iter(Ecs.IterPointerCallback<T0> callback)
     {
         TypeHelper<T0>.AssertReferenceTypes(false);
+        TypeHelper<T0>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -63,6 +68,7 @@ public void Iter(Ecs.IterPointerCallback<T0> callback)
     public void Iter(delegate*<Iter, Field<T0>, void> callback)
     {
         TypeHelper<T0>.AssertReferenceTypes(true);
+        TypeHelper<T0>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -73,6 +79,7 @@ public void Iter(delegate*<Iter, Field<T0>, void> callback)
     public void Iter(delegate*<Iter, Span<T0>, void> callback)
     {
         TypeHelper<T0>.AssertReferenceTypes(false);
+        TypeHelper<T0>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -83,6 +90,7 @@ public void Iter(delegate*<Iter, Span<T0>, void> callback)
     public void Iter(delegate*<Iter, T0*, void> callback)
     {
         TypeHelper<T0>.AssertReferenceTypes(false);
+        TypeHelper<T0>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -93,6 +101,7 @@ public void Iter(delegate*<Iter, T0*, void> callback)
     public void Each(Ecs.EachRefCallback<T0> callback)
     {
         TypeHelper<T0>.AssertReferenceTypes(true);
+        TypeHelper<T0>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -103,6 +112,7 @@ public void Each(Ecs.EachRefCallback<T0> callback)
     public void Each(Ecs.EachEntityRefCallback<T0> callback)
     {
         TypeHelper<T0>.AssertReferenceTypes(true);
+        TypeHelper<T0>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -113,6 +123,7 @@ public void Each(Ecs.EachEntityRefCallback<T0> callback)
     public void Each(Ecs.EachIterRefCallback<T0> callback)
     {
         TypeHelper<T0>.AssertReferenceTypes(true);
+        TypeHelper<T0>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -123,6 +134,7 @@ public void Each(Ecs.EachIterRefCallback<T0> callback)
     public void Each(delegate*<ref T0, void> callback)
     {
         TypeHelper<T0>.AssertReferenceTypes(true);
+        TypeHelper<T0>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -133,6 +145,7 @@ public void Each(delegate*<ref T0, void> callback)
     public void Each(delegate*<Entity, ref T0, void> callback)
     {
         TypeHelper<T0>.AssertReferenceTypes(true);
+        TypeHelper<T0>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -143,6 +156,7 @@ public void Each(delegate*<Entity, ref T0, void> callback)
     public void Each(delegate*<Iter, int, ref T0, void> callback)
     {
         TypeHelper<T0>.AssertReferenceTypes(true);
+        TypeHelper<T0>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -153,6 +167,7 @@ public void Each(delegate*<Iter, int, ref T0, void> callback)
     public void Each(Ecs.EachPointerCallback<T0> callback)
     {
         TypeHelper<T0>.AssertReferenceTypes(false);
+        TypeHelper<T0>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -163,6 +178,7 @@ public void Each(Ecs.EachPointerCallback<T0> callback)
     public void Each(Ecs.EachEntityPointerCallback<T0> callback)
     {
         TypeHelper<T0>.AssertReferenceTypes(false);
+        TypeHelper<T0>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -173,6 +189,7 @@ public void Each(Ecs.EachEntityPointerCallback<T0> callback)
     public void Each(Ecs.EachIterPointerCallback<T0> callback)
     {
         TypeHelper<T0>.AssertReferenceTypes(false);
+        TypeHelper<T0>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -183,6 +200,7 @@ public void Each(Ecs.EachIterPointerCallback<T0> callback)
     public void Each(delegate*<T0*, void> callback)
     {
         TypeHelper<T0>.AssertReferenceTypes(false);
+        TypeHelper<T0>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -193,6 +211,7 @@ public void Each(delegate*<T0*, void> callback)
     public void Each(delegate*<Entity, T0*, void> callback)
     {
         TypeHelper<T0>.AssertReferenceTypes(false);
+        TypeHelper<T0>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -203,6 +222,7 @@ public void Each(delegate*<Entity, T0*, void> callback)
     public void Each(delegate*<Iter, int, T0*, void> callback)
     {
         TypeHelper<T0>.AssertReferenceTypes(false);
+        TypeHelper<T0>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -213,6 +233,7 @@ public void Each(delegate*<Iter, int, T0*, void> callback)
     public Entity Find(Ecs.FindRefCallback<T0> callback)
     {
         TypeHelper<T0>.AssertReferenceTypes(true);
+        TypeHelper<T0>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -223,6 +244,7 @@ public Entity Find(Ecs.FindRefCallback<T0> callback)
     public Entity Find(Ecs.FindEntityRefCallback<T0> callback)
     {
         TypeHelper<T0>.AssertReferenceTypes(true);
+        TypeHelper<T0>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -233,6 +255,7 @@ public Entity Find(Ecs.FindEntityRefCallback<T0> callback)
     public Entity Find(Ecs.FindIterRefCallback<T0> callback)
     {
         TypeHelper<T0>.AssertReferenceTypes(true);
+        TypeHelper<T0>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -243,6 +266,7 @@ public Entity Find(Ecs.FindIterRefCallback<T0> callback)
     public Entity Find(delegate*<ref T0, bool> callback)
     {
         TypeHelper<T0>.AssertReferenceTypes(true);
+        TypeHelper<T0>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -253,6 +277,7 @@ public Entity Find(delegate*<ref T0, bool> callback)
     public Entity Find(delegate*<Entity, ref T0, bool> callback)
     {
         TypeHelper<T0>.AssertReferenceTypes(true);
+        TypeHelper<T0>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -263,6 +288,7 @@ public Entity Find(delegate*<Entity, ref T0, bool> callback)
     public Entity Find(delegate*<Iter, int, ref T0, bool> callback)
     {
         TypeHelper<T0>.AssertReferenceTypes(true);
+        TypeHelper<T0>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -273,6 +299,7 @@ public Entity Find(delegate*<Iter, int, ref T0, bool> callback)
     public Entity Find(Ecs.FindPointerCallback<T0> callback)
     {
         TypeHelper<T0>.AssertReferenceTypes(false);
+        TypeHelper<T0>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -283,6 +310,7 @@ public Entity Find(Ecs.FindPointerCallback<T0> callback)
     public Entity Find(Ecs.FindEntityPointerCallback<T0> callback)
     {
         TypeHelper<T0>.AssertReferenceTypes(false);
+        TypeHelper<T0>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -293,6 +321,7 @@ public Entity Find(Ecs.FindEntityPointerCallback<T0> callback)
     public Entity Find(Ecs.FindIterPointerCallback<T0> callback)
     {
         TypeHelper<T0>.AssertReferenceTypes(false);
+        TypeHelper<T0>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -303,6 +332,7 @@ public Entity Find(Ecs.FindIterPointerCallback<T0> callback)
     public Entity Find(delegate*<T0*, bool> callback)
     {
         TypeHelper<T0>.AssertReferenceTypes(false);
+        TypeHelper<T0>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -313,6 +343,7 @@ public Entity Find(delegate*<T0*, bool> callback)
     public Entity Find(delegate*<Entity, T0*, bool> callback)
     {
         TypeHelper<T0>.AssertReferenceTypes(false);
+        TypeHelper<T0>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -323,6 +354,7 @@ public Entity Find(delegate*<Entity, T0*, bool> callback)
     public Entity Find(delegate*<Iter, int, T0*, bool> callback)
     {
         TypeHelper<T0>.AssertReferenceTypes(false);
+        TypeHelper<T0>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 }
\ No newline at end of file
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/PageIterable/PageIterable.IIterable/T10.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/PageIterable/PageIterable.IIterable/T10.g.cs
index ca01ecda..57f9ad10 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/PageIterable/PageIterable.IIterable/T10.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/PageIterable/PageIterable.IIterable/T10.g.cs
@@ -13,6 +13,7 @@ public unsafe partial struct PageIterable<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9
     public void Run(Ecs.RunCallback callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Run(ref this, callback);
     }
 
@@ -23,6 +24,7 @@ public void Run(Ecs.RunCallback callback)
     public void Run(delegate*<Iter, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Run(ref this, callback);
     }
 
@@ -33,6 +35,7 @@ public void Run(delegate*<Iter, void> callback)
     public void Iter(Ecs.IterFieldCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -43,6 +46,7 @@ public void Iter(Ecs.IterFieldCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> c
     public void Iter(Ecs.IterSpanCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -53,6 +57,7 @@ public void Iter(Ecs.IterSpanCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> ca
     public void Iter(Ecs.IterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -63,6 +68,7 @@ public void Iter(Ecs.IterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>
     public void Iter(delegate*<Iter, Field<T0>, Field<T1>, Field<T2>, Field<T3>, Field<T4>, Field<T5>, Field<T6>, Field<T7>, Field<T8>, Field<T9>, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -73,6 +79,7 @@ public void Iter(delegate*<Iter, Field<T0>, Field<T1>, Field<T2>, Field<T3>, Fie
     public void Iter(delegate*<Iter, Span<T0>, Span<T1>, Span<T2>, Span<T3>, Span<T4>, Span<T5>, Span<T6>, Span<T7>, Span<T8>, Span<T9>, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -83,6 +90,7 @@ public void Iter(delegate*<Iter, Span<T0>, Span<T1>, Span<T2>, Span<T3>, Span<T4
     public void Iter(delegate*<Iter, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -93,6 +101,7 @@ public void Iter(delegate*<Iter, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9
     public void Each(Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -103,6 +112,7 @@ public void Each(Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> cal
     public void Each(Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -113,6 +123,7 @@ public void Each(Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T
     public void Each(Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -123,6 +134,7 @@ public void Each(Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>
     public void Each(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -133,6 +145,7 @@ public void Each(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T
     public void Each(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -143,6 +156,7 @@ public void Each(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T
     public void Each(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -153,6 +167,7 @@ public void Each(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, re
     public void Each(Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -163,6 +178,7 @@ public void Each(Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>
     public void Each(Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -173,6 +189,7 @@ public void Each(Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T
     public void Each(Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -183,6 +200,7 @@ public void Each(Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8,
     public void Each(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -193,6 +211,7 @@ public void Each(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, voi
     public void Each(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -203,6 +222,7 @@ public void Each(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*,
     public void Each(delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -213,6 +233,7 @@ public void Each(delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8
     public Entity Find(Ecs.FindRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -223,6 +244,7 @@ public Entity Find(Ecs.FindRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> c
     public Entity Find(Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -233,6 +255,7 @@ public Entity Find(Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8,
     public Entity Find(Ecs.FindIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -243,6 +266,7 @@ public Entity Find(Ecs.FindIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T
     public Entity Find(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -253,6 +277,7 @@ public Entity Find(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref
     public Entity Find(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -263,6 +288,7 @@ public Entity Find(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref
     public Entity Find(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -273,6 +299,7 @@ public Entity Find(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4,
     public Entity Find(Ecs.FindPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -283,6 +310,7 @@ public Entity Find(Ecs.FindPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T
     public Entity Find(Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -293,6 +321,7 @@ public Entity Find(Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7,
     public Entity Find(Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -303,6 +332,7 @@ public Entity Find(Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T
     public Entity Find(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -313,6 +343,7 @@ public Entity Find(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, b
     public Entity Find(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -323,6 +354,7 @@ public Entity Find(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*
     public Entity Find(delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 }
\ No newline at end of file
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/PageIterable/PageIterable.IIterable/T11.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/PageIterable/PageIterable.IIterable/T11.g.cs
index 32bae477..141d9dfc 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/PageIterable/PageIterable.IIterable/T11.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/PageIterable/PageIterable.IIterable/T11.g.cs
@@ -13,6 +13,7 @@ public unsafe partial struct PageIterable<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9
     public void Run(Ecs.RunCallback callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Run(ref this, callback);
     }
 
@@ -23,6 +24,7 @@ public void Run(Ecs.RunCallback callback)
     public void Run(delegate*<Iter, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Run(ref this, callback);
     }
 
@@ -33,6 +35,7 @@ public void Run(delegate*<Iter, void> callback)
     public void Iter(Ecs.IterFieldCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -43,6 +46,7 @@ public void Iter(Ecs.IterFieldCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T
     public void Iter(Ecs.IterSpanCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -53,6 +57,7 @@ public void Iter(Ecs.IterSpanCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T1
     public void Iter(Ecs.IterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -63,6 +68,7 @@ public void Iter(Ecs.IterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9,
     public void Iter(delegate*<Iter, Field<T0>, Field<T1>, Field<T2>, Field<T3>, Field<T4>, Field<T5>, Field<T6>, Field<T7>, Field<T8>, Field<T9>, Field<T10>, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -73,6 +79,7 @@ public void Iter(delegate*<Iter, Field<T0>, Field<T1>, Field<T2>, Field<T3>, Fie
     public void Iter(delegate*<Iter, Span<T0>, Span<T1>, Span<T2>, Span<T3>, Span<T4>, Span<T5>, Span<T6>, Span<T7>, Span<T8>, Span<T9>, Span<T10>, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -83,6 +90,7 @@ public void Iter(delegate*<Iter, Span<T0>, Span<T1>, Span<T2>, Span<T3>, Span<T4
     public void Iter(delegate*<Iter, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -93,6 +101,7 @@ public void Iter(delegate*<Iter, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9
     public void Each(Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -103,6 +112,7 @@ public void Each(Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10
     public void Each(Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -113,6 +123,7 @@ public void Each(Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T
     public void Each(Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -123,6 +134,7 @@ public void Each(Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9,
     public void Each(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -133,6 +145,7 @@ public void Each(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T
     public void Each(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -143,6 +156,7 @@ public void Each(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T
     public void Each(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -153,6 +167,7 @@ public void Each(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, re
     public void Each(Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -163,6 +178,7 @@ public void Each(Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9,
     public void Each(Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -173,6 +189,7 @@ public void Each(Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T
     public void Each(Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -183,6 +200,7 @@ public void Each(Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8,
     public void Each(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -193,6 +211,7 @@ public void Each(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10
     public void Each(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -203,6 +222,7 @@ public void Each(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*,
     public void Each(delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -213,6 +233,7 @@ public void Each(delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8
     public Entity Find(Ecs.FindRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -223,6 +244,7 @@ public Entity Find(Ecs.FindRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T
     public Entity Find(Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -233,6 +255,7 @@ public Entity Find(Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8,
     public Entity Find(Ecs.FindIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -243,6 +266,7 @@ public Entity Find(Ecs.FindIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T
     public Entity Find(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -253,6 +277,7 @@ public Entity Find(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref
     public Entity Find(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -263,6 +288,7 @@ public Entity Find(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref
     public Entity Find(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -273,6 +299,7 @@ public Entity Find(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4,
     public Entity Find(Ecs.FindPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -283,6 +310,7 @@ public Entity Find(Ecs.FindPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T
     public Entity Find(Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -293,6 +321,7 @@ public Entity Find(Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7,
     public Entity Find(Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -303,6 +332,7 @@ public Entity Find(Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T
     public Entity Find(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -313,6 +343,7 @@ public Entity Find(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T
     public Entity Find(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -323,6 +354,7 @@ public Entity Find(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*
     public Entity Find(delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 }
\ No newline at end of file
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/PageIterable/PageIterable.IIterable/T12.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/PageIterable/PageIterable.IIterable/T12.g.cs
index 1b4aeded..70499f20 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/PageIterable/PageIterable.IIterable/T12.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/PageIterable/PageIterable.IIterable/T12.g.cs
@@ -13,6 +13,7 @@ public unsafe partial struct PageIterable<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9
     public void Run(Ecs.RunCallback callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Run(ref this, callback);
     }
 
@@ -23,6 +24,7 @@ public void Run(Ecs.RunCallback callback)
     public void Run(delegate*<Iter, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Run(ref this, callback);
     }
 
@@ -33,6 +35,7 @@ public void Run(delegate*<Iter, void> callback)
     public void Iter(Ecs.IterFieldCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -43,6 +46,7 @@ public void Iter(Ecs.IterFieldCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T
     public void Iter(Ecs.IterSpanCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -53,6 +57,7 @@ public void Iter(Ecs.IterSpanCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T1
     public void Iter(Ecs.IterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -63,6 +68,7 @@ public void Iter(Ecs.IterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9,
     public void Iter(delegate*<Iter, Field<T0>, Field<T1>, Field<T2>, Field<T3>, Field<T4>, Field<T5>, Field<T6>, Field<T7>, Field<T8>, Field<T9>, Field<T10>, Field<T11>, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -73,6 +79,7 @@ public void Iter(delegate*<Iter, Field<T0>, Field<T1>, Field<T2>, Field<T3>, Fie
     public void Iter(delegate*<Iter, Span<T0>, Span<T1>, Span<T2>, Span<T3>, Span<T4>, Span<T5>, Span<T6>, Span<T7>, Span<T8>, Span<T9>, Span<T10>, Span<T11>, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -83,6 +90,7 @@ public void Iter(delegate*<Iter, Span<T0>, Span<T1>, Span<T2>, Span<T3>, Span<T4
     public void Iter(delegate*<Iter, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -93,6 +101,7 @@ public void Iter(delegate*<Iter, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9
     public void Each(Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -103,6 +112,7 @@ public void Each(Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10
     public void Each(Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -113,6 +123,7 @@ public void Each(Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T
     public void Each(Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -123,6 +134,7 @@ public void Each(Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9,
     public void Each(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -133,6 +145,7 @@ public void Each(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T
     public void Each(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -143,6 +156,7 @@ public void Each(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T
     public void Each(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -153,6 +167,7 @@ public void Each(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, re
     public void Each(Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -163,6 +178,7 @@ public void Each(Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9,
     public void Each(Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -173,6 +189,7 @@ public void Each(Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T
     public void Each(Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -183,6 +200,7 @@ public void Each(Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8,
     public void Each(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -193,6 +211,7 @@ public void Each(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10
     public void Each(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -203,6 +222,7 @@ public void Each(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*,
     public void Each(delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -213,6 +233,7 @@ public void Each(delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8
     public Entity Find(Ecs.FindRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -223,6 +244,7 @@ public Entity Find(Ecs.FindRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T
     public Entity Find(Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -233,6 +255,7 @@ public Entity Find(Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8,
     public Entity Find(Ecs.FindIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -243,6 +266,7 @@ public Entity Find(Ecs.FindIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T
     public Entity Find(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -253,6 +277,7 @@ public Entity Find(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref
     public Entity Find(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -263,6 +288,7 @@ public Entity Find(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref
     public Entity Find(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -273,6 +299,7 @@ public Entity Find(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4,
     public Entity Find(Ecs.FindPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -283,6 +310,7 @@ public Entity Find(Ecs.FindPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T
     public Entity Find(Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -293,6 +321,7 @@ public Entity Find(Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7,
     public Entity Find(Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -303,6 +332,7 @@ public Entity Find(Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T
     public Entity Find(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -313,6 +343,7 @@ public Entity Find(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T
     public Entity Find(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -323,6 +354,7 @@ public Entity Find(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*
     public Entity Find(delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 }
\ No newline at end of file
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/PageIterable/PageIterable.IIterable/T13.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/PageIterable/PageIterable.IIterable/T13.g.cs
index 9a6ac4de..03eb1a82 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/PageIterable/PageIterable.IIterable/T13.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/PageIterable/PageIterable.IIterable/T13.g.cs
@@ -13,6 +13,7 @@ public unsafe partial struct PageIterable<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9
     public void Run(Ecs.RunCallback callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Run(ref this, callback);
     }
 
@@ -23,6 +24,7 @@ public void Run(Ecs.RunCallback callback)
     public void Run(delegate*<Iter, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Run(ref this, callback);
     }
 
@@ -33,6 +35,7 @@ public void Run(delegate*<Iter, void> callback)
     public void Iter(Ecs.IterFieldCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -43,6 +46,7 @@ public void Iter(Ecs.IterFieldCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T
     public void Iter(Ecs.IterSpanCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -53,6 +57,7 @@ public void Iter(Ecs.IterSpanCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T1
     public void Iter(Ecs.IterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -63,6 +68,7 @@ public void Iter(Ecs.IterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9,
     public void Iter(delegate*<Iter, Field<T0>, Field<T1>, Field<T2>, Field<T3>, Field<T4>, Field<T5>, Field<T6>, Field<T7>, Field<T8>, Field<T9>, Field<T10>, Field<T11>, Field<T12>, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -73,6 +79,7 @@ public void Iter(delegate*<Iter, Field<T0>, Field<T1>, Field<T2>, Field<T3>, Fie
     public void Iter(delegate*<Iter, Span<T0>, Span<T1>, Span<T2>, Span<T3>, Span<T4>, Span<T5>, Span<T6>, Span<T7>, Span<T8>, Span<T9>, Span<T10>, Span<T11>, Span<T12>, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -83,6 +90,7 @@ public void Iter(delegate*<Iter, Span<T0>, Span<T1>, Span<T2>, Span<T3>, Span<T4
     public void Iter(delegate*<Iter, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -93,6 +101,7 @@ public void Iter(delegate*<Iter, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9
     public void Each(Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -103,6 +112,7 @@ public void Each(Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10
     public void Each(Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -113,6 +123,7 @@ public void Each(Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T
     public void Each(Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -123,6 +134,7 @@ public void Each(Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9,
     public void Each(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -133,6 +145,7 @@ public void Each(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T
     public void Each(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -143,6 +156,7 @@ public void Each(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T
     public void Each(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -153,6 +167,7 @@ public void Each(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, re
     public void Each(Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -163,6 +178,7 @@ public void Each(Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9,
     public void Each(Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -173,6 +189,7 @@ public void Each(Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T
     public void Each(Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -183,6 +200,7 @@ public void Each(Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8,
     public void Each(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -193,6 +211,7 @@ public void Each(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10
     public void Each(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -203,6 +222,7 @@ public void Each(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*,
     public void Each(delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -213,6 +233,7 @@ public void Each(delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8
     public Entity Find(Ecs.FindRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -223,6 +244,7 @@ public Entity Find(Ecs.FindRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T
     public Entity Find(Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -233,6 +255,7 @@ public Entity Find(Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8,
     public Entity Find(Ecs.FindIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -243,6 +266,7 @@ public Entity Find(Ecs.FindIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T
     public Entity Find(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -253,6 +277,7 @@ public Entity Find(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref
     public Entity Find(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -263,6 +288,7 @@ public Entity Find(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref
     public Entity Find(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -273,6 +299,7 @@ public Entity Find(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4,
     public Entity Find(Ecs.FindPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -283,6 +310,7 @@ public Entity Find(Ecs.FindPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T
     public Entity Find(Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -293,6 +321,7 @@ public Entity Find(Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7,
     public Entity Find(Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -303,6 +332,7 @@ public Entity Find(Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T
     public Entity Find(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -313,6 +343,7 @@ public Entity Find(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T
     public Entity Find(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -323,6 +354,7 @@ public Entity Find(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*
     public Entity Find(delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 }
\ No newline at end of file
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/PageIterable/PageIterable.IIterable/T14.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/PageIterable/PageIterable.IIterable/T14.g.cs
index 67593d04..8b833a19 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/PageIterable/PageIterable.IIterable/T14.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/PageIterable/PageIterable.IIterable/T14.g.cs
@@ -13,6 +13,7 @@ public unsafe partial struct PageIterable<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9
     public void Run(Ecs.RunCallback callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Run(ref this, callback);
     }
 
@@ -23,6 +24,7 @@ public void Run(Ecs.RunCallback callback)
     public void Run(delegate*<Iter, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Run(ref this, callback);
     }
 
@@ -33,6 +35,7 @@ public void Run(delegate*<Iter, void> callback)
     public void Iter(Ecs.IterFieldCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -43,6 +46,7 @@ public void Iter(Ecs.IterFieldCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T
     public void Iter(Ecs.IterSpanCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -53,6 +57,7 @@ public void Iter(Ecs.IterSpanCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T1
     public void Iter(Ecs.IterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -63,6 +68,7 @@ public void Iter(Ecs.IterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9,
     public void Iter(delegate*<Iter, Field<T0>, Field<T1>, Field<T2>, Field<T3>, Field<T4>, Field<T5>, Field<T6>, Field<T7>, Field<T8>, Field<T9>, Field<T10>, Field<T11>, Field<T12>, Field<T13>, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -73,6 +79,7 @@ public void Iter(delegate*<Iter, Field<T0>, Field<T1>, Field<T2>, Field<T3>, Fie
     public void Iter(delegate*<Iter, Span<T0>, Span<T1>, Span<T2>, Span<T3>, Span<T4>, Span<T5>, Span<T6>, Span<T7>, Span<T8>, Span<T9>, Span<T10>, Span<T11>, Span<T12>, Span<T13>, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -83,6 +90,7 @@ public void Iter(delegate*<Iter, Span<T0>, Span<T1>, Span<T2>, Span<T3>, Span<T4
     public void Iter(delegate*<Iter, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -93,6 +101,7 @@ public void Iter(delegate*<Iter, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9
     public void Each(Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -103,6 +112,7 @@ public void Each(Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10
     public void Each(Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -113,6 +123,7 @@ public void Each(Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T
     public void Each(Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -123,6 +134,7 @@ public void Each(Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9,
     public void Each(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -133,6 +145,7 @@ public void Each(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T
     public void Each(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -143,6 +156,7 @@ public void Each(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T
     public void Each(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -153,6 +167,7 @@ public void Each(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, re
     public void Each(Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -163,6 +178,7 @@ public void Each(Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9,
     public void Each(Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -173,6 +189,7 @@ public void Each(Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T
     public void Each(Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -183,6 +200,7 @@ public void Each(Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8,
     public void Each(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -193,6 +211,7 @@ public void Each(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10
     public void Each(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -203,6 +222,7 @@ public void Each(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*,
     public void Each(delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -213,6 +233,7 @@ public void Each(delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8
     public Entity Find(Ecs.FindRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -223,6 +244,7 @@ public Entity Find(Ecs.FindRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T
     public Entity Find(Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -233,6 +255,7 @@ public Entity Find(Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8,
     public Entity Find(Ecs.FindIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -243,6 +266,7 @@ public Entity Find(Ecs.FindIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T
     public Entity Find(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -253,6 +277,7 @@ public Entity Find(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref
     public Entity Find(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -263,6 +288,7 @@ public Entity Find(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref
     public Entity Find(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -273,6 +299,7 @@ public Entity Find(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4,
     public Entity Find(Ecs.FindPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -283,6 +310,7 @@ public Entity Find(Ecs.FindPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T
     public Entity Find(Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -293,6 +321,7 @@ public Entity Find(Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7,
     public Entity Find(Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -303,6 +332,7 @@ public Entity Find(Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T
     public Entity Find(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -313,6 +343,7 @@ public Entity Find(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T
     public Entity Find(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -323,6 +354,7 @@ public Entity Find(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*
     public Entity Find(delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 }
\ No newline at end of file
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/PageIterable/PageIterable.IIterable/T15.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/PageIterable/PageIterable.IIterable/T15.g.cs
index 9e129e3b..c7007615 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/PageIterable/PageIterable.IIterable/T15.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/PageIterable/PageIterable.IIterable/T15.g.cs
@@ -13,6 +13,7 @@ public unsafe partial struct PageIterable<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9
     public void Run(Ecs.RunCallback callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Run(ref this, callback);
     }
 
@@ -23,6 +24,7 @@ public void Run(Ecs.RunCallback callback)
     public void Run(delegate*<Iter, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Run(ref this, callback);
     }
 
@@ -33,6 +35,7 @@ public void Run(delegate*<Iter, void> callback)
     public void Iter(Ecs.IterFieldCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -43,6 +46,7 @@ public void Iter(Ecs.IterFieldCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T
     public void Iter(Ecs.IterSpanCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -53,6 +57,7 @@ public void Iter(Ecs.IterSpanCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T1
     public void Iter(Ecs.IterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -63,6 +68,7 @@ public void Iter(Ecs.IterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9,
     public void Iter(delegate*<Iter, Field<T0>, Field<T1>, Field<T2>, Field<T3>, Field<T4>, Field<T5>, Field<T6>, Field<T7>, Field<T8>, Field<T9>, Field<T10>, Field<T11>, Field<T12>, Field<T13>, Field<T14>, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -73,6 +79,7 @@ public void Iter(delegate*<Iter, Field<T0>, Field<T1>, Field<T2>, Field<T3>, Fie
     public void Iter(delegate*<Iter, Span<T0>, Span<T1>, Span<T2>, Span<T3>, Span<T4>, Span<T5>, Span<T6>, Span<T7>, Span<T8>, Span<T9>, Span<T10>, Span<T11>, Span<T12>, Span<T13>, Span<T14>, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -83,6 +90,7 @@ public void Iter(delegate*<Iter, Span<T0>, Span<T1>, Span<T2>, Span<T3>, Span<T4
     public void Iter(delegate*<Iter, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, T14*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -93,6 +101,7 @@ public void Iter(delegate*<Iter, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9
     public void Each(Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -103,6 +112,7 @@ public void Each(Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10
     public void Each(Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -113,6 +123,7 @@ public void Each(Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T
     public void Each(Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -123,6 +134,7 @@ public void Each(Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9,
     public void Each(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, ref T14, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -133,6 +145,7 @@ public void Each(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T
     public void Each(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, ref T14, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -143,6 +156,7 @@ public void Each(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T
     public void Each(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, ref T14, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -153,6 +167,7 @@ public void Each(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, re
     public void Each(Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -163,6 +178,7 @@ public void Each(Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9,
     public void Each(Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -173,6 +189,7 @@ public void Each(Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T
     public void Each(Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -183,6 +200,7 @@ public void Each(Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8,
     public void Each(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, T14*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -193,6 +211,7 @@ public void Each(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10
     public void Each(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, T14*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -203,6 +222,7 @@ public void Each(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*,
     public void Each(delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, T14*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -213,6 +233,7 @@ public void Each(delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8
     public Entity Find(Ecs.FindRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -223,6 +244,7 @@ public Entity Find(Ecs.FindRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T
     public Entity Find(Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -233,6 +255,7 @@ public Entity Find(Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8,
     public Entity Find(Ecs.FindIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -243,6 +266,7 @@ public Entity Find(Ecs.FindIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T
     public Entity Find(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, ref T14, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -253,6 +277,7 @@ public Entity Find(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref
     public Entity Find(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, ref T14, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -263,6 +288,7 @@ public Entity Find(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref
     public Entity Find(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, ref T14, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -273,6 +299,7 @@ public Entity Find(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4,
     public Entity Find(Ecs.FindPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -283,6 +310,7 @@ public Entity Find(Ecs.FindPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T
     public Entity Find(Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -293,6 +321,7 @@ public Entity Find(Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7,
     public Entity Find(Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -303,6 +332,7 @@ public Entity Find(Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T
     public Entity Find(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, T14*, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -313,6 +343,7 @@ public Entity Find(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T
     public Entity Find(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, T14*, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -323,6 +354,7 @@ public Entity Find(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*
     public Entity Find(delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, T14*, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 }
\ No newline at end of file
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/PageIterable/PageIterable.IIterable/T16.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/PageIterable/PageIterable.IIterable/T16.g.cs
index 07a9828c..ae714a8e 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/PageIterable/PageIterable.IIterable/T16.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/PageIterable/PageIterable.IIterable/T16.g.cs
@@ -13,6 +13,7 @@ public unsafe partial struct PageIterable<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9
     public void Run(Ecs.RunCallback callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Run(ref this, callback);
     }
 
@@ -23,6 +24,7 @@ public void Run(Ecs.RunCallback callback)
     public void Run(delegate*<Iter, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Run(ref this, callback);
     }
 
@@ -33,6 +35,7 @@ public void Run(delegate*<Iter, void> callback)
     public void Iter(Ecs.IterFieldCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -43,6 +46,7 @@ public void Iter(Ecs.IterFieldCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T
     public void Iter(Ecs.IterSpanCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -53,6 +57,7 @@ public void Iter(Ecs.IterSpanCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T1
     public void Iter(Ecs.IterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -63,6 +68,7 @@ public void Iter(Ecs.IterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9,
     public void Iter(delegate*<Iter, Field<T0>, Field<T1>, Field<T2>, Field<T3>, Field<T4>, Field<T5>, Field<T6>, Field<T7>, Field<T8>, Field<T9>, Field<T10>, Field<T11>, Field<T12>, Field<T13>, Field<T14>, Field<T15>, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -73,6 +79,7 @@ public void Iter(delegate*<Iter, Field<T0>, Field<T1>, Field<T2>, Field<T3>, Fie
     public void Iter(delegate*<Iter, Span<T0>, Span<T1>, Span<T2>, Span<T3>, Span<T4>, Span<T5>, Span<T6>, Span<T7>, Span<T8>, Span<T9>, Span<T10>, Span<T11>, Span<T12>, Span<T13>, Span<T14>, Span<T15>, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -83,6 +90,7 @@ public void Iter(delegate*<Iter, Span<T0>, Span<T1>, Span<T2>, Span<T3>, Span<T4
     public void Iter(delegate*<Iter, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, T14*, T15*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -93,6 +101,7 @@ public void Iter(delegate*<Iter, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9
     public void Each(Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -103,6 +112,7 @@ public void Each(Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10
     public void Each(Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -113,6 +123,7 @@ public void Each(Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T
     public void Each(Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -123,6 +134,7 @@ public void Each(Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9,
     public void Each(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, ref T14, ref T15, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -133,6 +145,7 @@ public void Each(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T
     public void Each(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, ref T14, ref T15, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -143,6 +156,7 @@ public void Each(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T
     public void Each(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, ref T14, ref T15, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -153,6 +167,7 @@ public void Each(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, re
     public void Each(Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -163,6 +178,7 @@ public void Each(Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9,
     public void Each(Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -173,6 +189,7 @@ public void Each(Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T
     public void Each(Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -183,6 +200,7 @@ public void Each(Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8,
     public void Each(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, T14*, T15*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -193,6 +211,7 @@ public void Each(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10
     public void Each(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, T14*, T15*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -203,6 +222,7 @@ public void Each(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*,
     public void Each(delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, T14*, T15*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -213,6 +233,7 @@ public void Each(delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8
     public Entity Find(Ecs.FindRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -223,6 +244,7 @@ public Entity Find(Ecs.FindRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T
     public Entity Find(Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -233,6 +255,7 @@ public Entity Find(Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8,
     public Entity Find(Ecs.FindIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -243,6 +266,7 @@ public Entity Find(Ecs.FindIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T
     public Entity Find(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, ref T14, ref T15, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -253,6 +277,7 @@ public Entity Find(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref
     public Entity Find(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, ref T14, ref T15, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -263,6 +288,7 @@ public Entity Find(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref
     public Entity Find(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, ref T14, ref T15, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -273,6 +299,7 @@ public Entity Find(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4,
     public Entity Find(Ecs.FindPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -283,6 +310,7 @@ public Entity Find(Ecs.FindPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T
     public Entity Find(Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -293,6 +321,7 @@ public Entity Find(Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7,
     public Entity Find(Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -303,6 +332,7 @@ public Entity Find(Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T
     public Entity Find(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, T14*, T15*, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -313,6 +343,7 @@ public Entity Find(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T
     public Entity Find(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, T14*, T15*, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -323,6 +354,7 @@ public Entity Find(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*
     public Entity Find(delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, T14*, T15*, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 }
\ No newline at end of file
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/PageIterable/PageIterable.IIterable/T2.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/PageIterable/PageIterable.IIterable/T2.g.cs
index 05b9dca6..cbbc612e 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/PageIterable/PageIterable.IIterable/T2.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/PageIterable/PageIterable.IIterable/T2.g.cs
@@ -13,6 +13,7 @@ public unsafe partial struct PageIterable<T0, T1>
     public void Run(Ecs.RunCallback callback)
     {
         TypeHelper<T0, T1>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Run(ref this, callback);
     }
 
@@ -23,6 +24,7 @@ public void Run(Ecs.RunCallback callback)
     public void Run(delegate*<Iter, void> callback)
     {
         TypeHelper<T0, T1>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Run(ref this, callback);
     }
 
@@ -33,6 +35,7 @@ public void Run(delegate*<Iter, void> callback)
     public void Iter(Ecs.IterFieldCallback<T0, T1> callback)
     {
         TypeHelper<T0, T1>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -43,6 +46,7 @@ public void Iter(Ecs.IterFieldCallback<T0, T1> callback)
     public void Iter(Ecs.IterSpanCallback<T0, T1> callback)
     {
         TypeHelper<T0, T1>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -53,6 +57,7 @@ public void Iter(Ecs.IterSpanCallback<T0, T1> callback)
     public void Iter(Ecs.IterPointerCallback<T0, T1> callback)
     {
         TypeHelper<T0, T1>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -63,6 +68,7 @@ public void Iter(Ecs.IterPointerCallback<T0, T1> callback)
     public void Iter(delegate*<Iter, Field<T0>, Field<T1>, void> callback)
     {
         TypeHelper<T0, T1>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -73,6 +79,7 @@ public void Iter(delegate*<Iter, Field<T0>, Field<T1>, void> callback)
     public void Iter(delegate*<Iter, Span<T0>, Span<T1>, void> callback)
     {
         TypeHelper<T0, T1>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -83,6 +90,7 @@ public void Iter(delegate*<Iter, Span<T0>, Span<T1>, void> callback)
     public void Iter(delegate*<Iter, T0*, T1*, void> callback)
     {
         TypeHelper<T0, T1>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -93,6 +101,7 @@ public void Iter(delegate*<Iter, T0*, T1*, void> callback)
     public void Each(Ecs.EachRefCallback<T0, T1> callback)
     {
         TypeHelper<T0, T1>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -103,6 +112,7 @@ public void Each(Ecs.EachRefCallback<T0, T1> callback)
     public void Each(Ecs.EachEntityRefCallback<T0, T1> callback)
     {
         TypeHelper<T0, T1>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -113,6 +123,7 @@ public void Each(Ecs.EachEntityRefCallback<T0, T1> callback)
     public void Each(Ecs.EachIterRefCallback<T0, T1> callback)
     {
         TypeHelper<T0, T1>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -123,6 +134,7 @@ public void Each(Ecs.EachIterRefCallback<T0, T1> callback)
     public void Each(delegate*<ref T0, ref T1, void> callback)
     {
         TypeHelper<T0, T1>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -133,6 +145,7 @@ public void Each(delegate*<ref T0, ref T1, void> callback)
     public void Each(delegate*<Entity, ref T0, ref T1, void> callback)
     {
         TypeHelper<T0, T1>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -143,6 +156,7 @@ public void Each(delegate*<Entity, ref T0, ref T1, void> callback)
     public void Each(delegate*<Iter, int, ref T0, ref T1, void> callback)
     {
         TypeHelper<T0, T1>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -153,6 +167,7 @@ public void Each(delegate*<Iter, int, ref T0, ref T1, void> callback)
     public void Each(Ecs.EachPointerCallback<T0, T1> callback)
     {
         TypeHelper<T0, T1>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -163,6 +178,7 @@ public void Each(Ecs.EachPointerCallback<T0, T1> callback)
     public void Each(Ecs.EachEntityPointerCallback<T0, T1> callback)
     {
         TypeHelper<T0, T1>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -173,6 +189,7 @@ public void Each(Ecs.EachEntityPointerCallback<T0, T1> callback)
     public void Each(Ecs.EachIterPointerCallback<T0, T1> callback)
     {
         TypeHelper<T0, T1>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -183,6 +200,7 @@ public void Each(Ecs.EachIterPointerCallback<T0, T1> callback)
     public void Each(delegate*<T0*, T1*, void> callback)
     {
         TypeHelper<T0, T1>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -193,6 +211,7 @@ public void Each(delegate*<T0*, T1*, void> callback)
     public void Each(delegate*<Entity, T0*, T1*, void> callback)
     {
         TypeHelper<T0, T1>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -203,6 +222,7 @@ public void Each(delegate*<Entity, T0*, T1*, void> callback)
     public void Each(delegate*<Iter, int, T0*, T1*, void> callback)
     {
         TypeHelper<T0, T1>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -213,6 +233,7 @@ public void Each(delegate*<Iter, int, T0*, T1*, void> callback)
     public Entity Find(Ecs.FindRefCallback<T0, T1> callback)
     {
         TypeHelper<T0, T1>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -223,6 +244,7 @@ public Entity Find(Ecs.FindRefCallback<T0, T1> callback)
     public Entity Find(Ecs.FindEntityRefCallback<T0, T1> callback)
     {
         TypeHelper<T0, T1>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -233,6 +255,7 @@ public Entity Find(Ecs.FindEntityRefCallback<T0, T1> callback)
     public Entity Find(Ecs.FindIterRefCallback<T0, T1> callback)
     {
         TypeHelper<T0, T1>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -243,6 +266,7 @@ public Entity Find(Ecs.FindIterRefCallback<T0, T1> callback)
     public Entity Find(delegate*<ref T0, ref T1, bool> callback)
     {
         TypeHelper<T0, T1>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -253,6 +277,7 @@ public Entity Find(delegate*<ref T0, ref T1, bool> callback)
     public Entity Find(delegate*<Entity, ref T0, ref T1, bool> callback)
     {
         TypeHelper<T0, T1>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -263,6 +288,7 @@ public Entity Find(delegate*<Entity, ref T0, ref T1, bool> callback)
     public Entity Find(delegate*<Iter, int, ref T0, ref T1, bool> callback)
     {
         TypeHelper<T0, T1>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -273,6 +299,7 @@ public Entity Find(delegate*<Iter, int, ref T0, ref T1, bool> callback)
     public Entity Find(Ecs.FindPointerCallback<T0, T1> callback)
     {
         TypeHelper<T0, T1>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -283,6 +310,7 @@ public Entity Find(Ecs.FindPointerCallback<T0, T1> callback)
     public Entity Find(Ecs.FindEntityPointerCallback<T0, T1> callback)
     {
         TypeHelper<T0, T1>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -293,6 +321,7 @@ public Entity Find(Ecs.FindEntityPointerCallback<T0, T1> callback)
     public Entity Find(Ecs.FindIterPointerCallback<T0, T1> callback)
     {
         TypeHelper<T0, T1>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -303,6 +332,7 @@ public Entity Find(Ecs.FindIterPointerCallback<T0, T1> callback)
     public Entity Find(delegate*<T0*, T1*, bool> callback)
     {
         TypeHelper<T0, T1>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -313,6 +343,7 @@ public Entity Find(delegate*<T0*, T1*, bool> callback)
     public Entity Find(delegate*<Entity, T0*, T1*, bool> callback)
     {
         TypeHelper<T0, T1>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -323,6 +354,7 @@ public Entity Find(delegate*<Entity, T0*, T1*, bool> callback)
     public Entity Find(delegate*<Iter, int, T0*, T1*, bool> callback)
     {
         TypeHelper<T0, T1>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 }
\ No newline at end of file
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/PageIterable/PageIterable.IIterable/T3.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/PageIterable/PageIterable.IIterable/T3.g.cs
index ad775c5a..ad35011a 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/PageIterable/PageIterable.IIterable/T3.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/PageIterable/PageIterable.IIterable/T3.g.cs
@@ -13,6 +13,7 @@ public unsafe partial struct PageIterable<T0, T1, T2>
     public void Run(Ecs.RunCallback callback)
     {
         TypeHelper<T0, T1, T2>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Run(ref this, callback);
     }
 
@@ -23,6 +24,7 @@ public void Run(Ecs.RunCallback callback)
     public void Run(delegate*<Iter, void> callback)
     {
         TypeHelper<T0, T1, T2>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Run(ref this, callback);
     }
 
@@ -33,6 +35,7 @@ public void Run(delegate*<Iter, void> callback)
     public void Iter(Ecs.IterFieldCallback<T0, T1, T2> callback)
     {
         TypeHelper<T0, T1, T2>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -43,6 +46,7 @@ public void Iter(Ecs.IterFieldCallback<T0, T1, T2> callback)
     public void Iter(Ecs.IterSpanCallback<T0, T1, T2> callback)
     {
         TypeHelper<T0, T1, T2>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -53,6 +57,7 @@ public void Iter(Ecs.IterSpanCallback<T0, T1, T2> callback)
     public void Iter(Ecs.IterPointerCallback<T0, T1, T2> callback)
     {
         TypeHelper<T0, T1, T2>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -63,6 +68,7 @@ public void Iter(Ecs.IterPointerCallback<T0, T1, T2> callback)
     public void Iter(delegate*<Iter, Field<T0>, Field<T1>, Field<T2>, void> callback)
     {
         TypeHelper<T0, T1, T2>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -73,6 +79,7 @@ public void Iter(delegate*<Iter, Field<T0>, Field<T1>, Field<T2>, void> callback
     public void Iter(delegate*<Iter, Span<T0>, Span<T1>, Span<T2>, void> callback)
     {
         TypeHelper<T0, T1, T2>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -83,6 +90,7 @@ public void Iter(delegate*<Iter, Span<T0>, Span<T1>, Span<T2>, void> callback)
     public void Iter(delegate*<Iter, T0*, T1*, T2*, void> callback)
     {
         TypeHelper<T0, T1, T2>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -93,6 +101,7 @@ public void Iter(delegate*<Iter, T0*, T1*, T2*, void> callback)
     public void Each(Ecs.EachRefCallback<T0, T1, T2> callback)
     {
         TypeHelper<T0, T1, T2>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -103,6 +112,7 @@ public void Each(Ecs.EachRefCallback<T0, T1, T2> callback)
     public void Each(Ecs.EachEntityRefCallback<T0, T1, T2> callback)
     {
         TypeHelper<T0, T1, T2>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -113,6 +123,7 @@ public void Each(Ecs.EachEntityRefCallback<T0, T1, T2> callback)
     public void Each(Ecs.EachIterRefCallback<T0, T1, T2> callback)
     {
         TypeHelper<T0, T1, T2>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -123,6 +134,7 @@ public void Each(Ecs.EachIterRefCallback<T0, T1, T2> callback)
     public void Each(delegate*<ref T0, ref T1, ref T2, void> callback)
     {
         TypeHelper<T0, T1, T2>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -133,6 +145,7 @@ public void Each(delegate*<ref T0, ref T1, ref T2, void> callback)
     public void Each(delegate*<Entity, ref T0, ref T1, ref T2, void> callback)
     {
         TypeHelper<T0, T1, T2>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -143,6 +156,7 @@ public void Each(delegate*<Entity, ref T0, ref T1, ref T2, void> callback)
     public void Each(delegate*<Iter, int, ref T0, ref T1, ref T2, void> callback)
     {
         TypeHelper<T0, T1, T2>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -153,6 +167,7 @@ public void Each(delegate*<Iter, int, ref T0, ref T1, ref T2, void> callback)
     public void Each(Ecs.EachPointerCallback<T0, T1, T2> callback)
     {
         TypeHelper<T0, T1, T2>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -163,6 +178,7 @@ public void Each(Ecs.EachPointerCallback<T0, T1, T2> callback)
     public void Each(Ecs.EachEntityPointerCallback<T0, T1, T2> callback)
     {
         TypeHelper<T0, T1, T2>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -173,6 +189,7 @@ public void Each(Ecs.EachEntityPointerCallback<T0, T1, T2> callback)
     public void Each(Ecs.EachIterPointerCallback<T0, T1, T2> callback)
     {
         TypeHelper<T0, T1, T2>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -183,6 +200,7 @@ public void Each(Ecs.EachIterPointerCallback<T0, T1, T2> callback)
     public void Each(delegate*<T0*, T1*, T2*, void> callback)
     {
         TypeHelper<T0, T1, T2>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -193,6 +211,7 @@ public void Each(delegate*<T0*, T1*, T2*, void> callback)
     public void Each(delegate*<Entity, T0*, T1*, T2*, void> callback)
     {
         TypeHelper<T0, T1, T2>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -203,6 +222,7 @@ public void Each(delegate*<Entity, T0*, T1*, T2*, void> callback)
     public void Each(delegate*<Iter, int, T0*, T1*, T2*, void> callback)
     {
         TypeHelper<T0, T1, T2>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -213,6 +233,7 @@ public void Each(delegate*<Iter, int, T0*, T1*, T2*, void> callback)
     public Entity Find(Ecs.FindRefCallback<T0, T1, T2> callback)
     {
         TypeHelper<T0, T1, T2>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -223,6 +244,7 @@ public Entity Find(Ecs.FindRefCallback<T0, T1, T2> callback)
     public Entity Find(Ecs.FindEntityRefCallback<T0, T1, T2> callback)
     {
         TypeHelper<T0, T1, T2>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -233,6 +255,7 @@ public Entity Find(Ecs.FindEntityRefCallback<T0, T1, T2> callback)
     public Entity Find(Ecs.FindIterRefCallback<T0, T1, T2> callback)
     {
         TypeHelper<T0, T1, T2>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -243,6 +266,7 @@ public Entity Find(Ecs.FindIterRefCallback<T0, T1, T2> callback)
     public Entity Find(delegate*<ref T0, ref T1, ref T2, bool> callback)
     {
         TypeHelper<T0, T1, T2>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -253,6 +277,7 @@ public Entity Find(delegate*<ref T0, ref T1, ref T2, bool> callback)
     public Entity Find(delegate*<Entity, ref T0, ref T1, ref T2, bool> callback)
     {
         TypeHelper<T0, T1, T2>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -263,6 +288,7 @@ public Entity Find(delegate*<Entity, ref T0, ref T1, ref T2, bool> callback)
     public Entity Find(delegate*<Iter, int, ref T0, ref T1, ref T2, bool> callback)
     {
         TypeHelper<T0, T1, T2>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -273,6 +299,7 @@ public Entity Find(delegate*<Iter, int, ref T0, ref T1, ref T2, bool> callback)
     public Entity Find(Ecs.FindPointerCallback<T0, T1, T2> callback)
     {
         TypeHelper<T0, T1, T2>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -283,6 +310,7 @@ public Entity Find(Ecs.FindPointerCallback<T0, T1, T2> callback)
     public Entity Find(Ecs.FindEntityPointerCallback<T0, T1, T2> callback)
     {
         TypeHelper<T0, T1, T2>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -293,6 +321,7 @@ public Entity Find(Ecs.FindEntityPointerCallback<T0, T1, T2> callback)
     public Entity Find(Ecs.FindIterPointerCallback<T0, T1, T2> callback)
     {
         TypeHelper<T0, T1, T2>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -303,6 +332,7 @@ public Entity Find(Ecs.FindIterPointerCallback<T0, T1, T2> callback)
     public Entity Find(delegate*<T0*, T1*, T2*, bool> callback)
     {
         TypeHelper<T0, T1, T2>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -313,6 +343,7 @@ public Entity Find(delegate*<T0*, T1*, T2*, bool> callback)
     public Entity Find(delegate*<Entity, T0*, T1*, T2*, bool> callback)
     {
         TypeHelper<T0, T1, T2>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -323,6 +354,7 @@ public Entity Find(delegate*<Entity, T0*, T1*, T2*, bool> callback)
     public Entity Find(delegate*<Iter, int, T0*, T1*, T2*, bool> callback)
     {
         TypeHelper<T0, T1, T2>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 }
\ No newline at end of file
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/PageIterable/PageIterable.IIterable/T4.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/PageIterable/PageIterable.IIterable/T4.g.cs
index 5e455699..f57a9d89 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/PageIterable/PageIterable.IIterable/T4.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/PageIterable/PageIterable.IIterable/T4.g.cs
@@ -13,6 +13,7 @@ public unsafe partial struct PageIterable<T0, T1, T2, T3>
     public void Run(Ecs.RunCallback callback)
     {
         TypeHelper<T0, T1, T2, T3>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Run(ref this, callback);
     }
 
@@ -23,6 +24,7 @@ public void Run(Ecs.RunCallback callback)
     public void Run(delegate*<Iter, void> callback)
     {
         TypeHelper<T0, T1, T2, T3>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Run(ref this, callback);
     }
 
@@ -33,6 +35,7 @@ public void Run(delegate*<Iter, void> callback)
     public void Iter(Ecs.IterFieldCallback<T0, T1, T2, T3> callback)
     {
         TypeHelper<T0, T1, T2, T3>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -43,6 +46,7 @@ public void Iter(Ecs.IterFieldCallback<T0, T1, T2, T3> callback)
     public void Iter(Ecs.IterSpanCallback<T0, T1, T2, T3> callback)
     {
         TypeHelper<T0, T1, T2, T3>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -53,6 +57,7 @@ public void Iter(Ecs.IterSpanCallback<T0, T1, T2, T3> callback)
     public void Iter(Ecs.IterPointerCallback<T0, T1, T2, T3> callback)
     {
         TypeHelper<T0, T1, T2, T3>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -63,6 +68,7 @@ public void Iter(Ecs.IterPointerCallback<T0, T1, T2, T3> callback)
     public void Iter(delegate*<Iter, Field<T0>, Field<T1>, Field<T2>, Field<T3>, void> callback)
     {
         TypeHelper<T0, T1, T2, T3>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -73,6 +79,7 @@ public void Iter(delegate*<Iter, Field<T0>, Field<T1>, Field<T2>, Field<T3>, voi
     public void Iter(delegate*<Iter, Span<T0>, Span<T1>, Span<T2>, Span<T3>, void> callback)
     {
         TypeHelper<T0, T1, T2, T3>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -83,6 +90,7 @@ public void Iter(delegate*<Iter, Span<T0>, Span<T1>, Span<T2>, Span<T3>, void> c
     public void Iter(delegate*<Iter, T0*, T1*, T2*, T3*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -93,6 +101,7 @@ public void Iter(delegate*<Iter, T0*, T1*, T2*, T3*, void> callback)
     public void Each(Ecs.EachRefCallback<T0, T1, T2, T3> callback)
     {
         TypeHelper<T0, T1, T2, T3>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -103,6 +112,7 @@ public void Each(Ecs.EachRefCallback<T0, T1, T2, T3> callback)
     public void Each(Ecs.EachEntityRefCallback<T0, T1, T2, T3> callback)
     {
         TypeHelper<T0, T1, T2, T3>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -113,6 +123,7 @@ public void Each(Ecs.EachEntityRefCallback<T0, T1, T2, T3> callback)
     public void Each(Ecs.EachIterRefCallback<T0, T1, T2, T3> callback)
     {
         TypeHelper<T0, T1, T2, T3>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -123,6 +134,7 @@ public void Each(Ecs.EachIterRefCallback<T0, T1, T2, T3> callback)
     public void Each(delegate*<ref T0, ref T1, ref T2, ref T3, void> callback)
     {
         TypeHelper<T0, T1, T2, T3>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -133,6 +145,7 @@ public void Each(delegate*<ref T0, ref T1, ref T2, ref T3, void> callback)
     public void Each(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, void> callback)
     {
         TypeHelper<T0, T1, T2, T3>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -143,6 +156,7 @@ public void Each(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, void> callbac
     public void Each(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, void> callback)
     {
         TypeHelper<T0, T1, T2, T3>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -153,6 +167,7 @@ public void Each(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, void> call
     public void Each(Ecs.EachPointerCallback<T0, T1, T2, T3> callback)
     {
         TypeHelper<T0, T1, T2, T3>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -163,6 +178,7 @@ public void Each(Ecs.EachPointerCallback<T0, T1, T2, T3> callback)
     public void Each(Ecs.EachEntityPointerCallback<T0, T1, T2, T3> callback)
     {
         TypeHelper<T0, T1, T2, T3>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -173,6 +189,7 @@ public void Each(Ecs.EachEntityPointerCallback<T0, T1, T2, T3> callback)
     public void Each(Ecs.EachIterPointerCallback<T0, T1, T2, T3> callback)
     {
         TypeHelper<T0, T1, T2, T3>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -183,6 +200,7 @@ public void Each(Ecs.EachIterPointerCallback<T0, T1, T2, T3> callback)
     public void Each(delegate*<T0*, T1*, T2*, T3*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -193,6 +211,7 @@ public void Each(delegate*<T0*, T1*, T2*, T3*, void> callback)
     public void Each(delegate*<Entity, T0*, T1*, T2*, T3*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -203,6 +222,7 @@ public void Each(delegate*<Entity, T0*, T1*, T2*, T3*, void> callback)
     public void Each(delegate*<Iter, int, T0*, T1*, T2*, T3*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -213,6 +233,7 @@ public void Each(delegate*<Iter, int, T0*, T1*, T2*, T3*, void> callback)
     public Entity Find(Ecs.FindRefCallback<T0, T1, T2, T3> callback)
     {
         TypeHelper<T0, T1, T2, T3>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -223,6 +244,7 @@ public Entity Find(Ecs.FindRefCallback<T0, T1, T2, T3> callback)
     public Entity Find(Ecs.FindEntityRefCallback<T0, T1, T2, T3> callback)
     {
         TypeHelper<T0, T1, T2, T3>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -233,6 +255,7 @@ public Entity Find(Ecs.FindEntityRefCallback<T0, T1, T2, T3> callback)
     public Entity Find(Ecs.FindIterRefCallback<T0, T1, T2, T3> callback)
     {
         TypeHelper<T0, T1, T2, T3>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -243,6 +266,7 @@ public Entity Find(Ecs.FindIterRefCallback<T0, T1, T2, T3> callback)
     public Entity Find(delegate*<ref T0, ref T1, ref T2, ref T3, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -253,6 +277,7 @@ public Entity Find(delegate*<ref T0, ref T1, ref T2, ref T3, bool> callback)
     public Entity Find(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -263,6 +288,7 @@ public Entity Find(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, bool> callb
     public Entity Find(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -273,6 +299,7 @@ public Entity Find(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, bool> ca
     public Entity Find(Ecs.FindPointerCallback<T0, T1, T2, T3> callback)
     {
         TypeHelper<T0, T1, T2, T3>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -283,6 +310,7 @@ public Entity Find(Ecs.FindPointerCallback<T0, T1, T2, T3> callback)
     public Entity Find(Ecs.FindEntityPointerCallback<T0, T1, T2, T3> callback)
     {
         TypeHelper<T0, T1, T2, T3>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -293,6 +321,7 @@ public Entity Find(Ecs.FindEntityPointerCallback<T0, T1, T2, T3> callback)
     public Entity Find(Ecs.FindIterPointerCallback<T0, T1, T2, T3> callback)
     {
         TypeHelper<T0, T1, T2, T3>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -303,6 +332,7 @@ public Entity Find(Ecs.FindIterPointerCallback<T0, T1, T2, T3> callback)
     public Entity Find(delegate*<T0*, T1*, T2*, T3*, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -313,6 +343,7 @@ public Entity Find(delegate*<T0*, T1*, T2*, T3*, bool> callback)
     public Entity Find(delegate*<Entity, T0*, T1*, T2*, T3*, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -323,6 +354,7 @@ public Entity Find(delegate*<Entity, T0*, T1*, T2*, T3*, bool> callback)
     public Entity Find(delegate*<Iter, int, T0*, T1*, T2*, T3*, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 }
\ No newline at end of file
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/PageIterable/PageIterable.IIterable/T5.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/PageIterable/PageIterable.IIterable/T5.g.cs
index 2783e1fe..57aef335 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/PageIterable/PageIterable.IIterable/T5.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/PageIterable/PageIterable.IIterable/T5.g.cs
@@ -13,6 +13,7 @@ public unsafe partial struct PageIterable<T0, T1, T2, T3, T4>
     public void Run(Ecs.RunCallback callback)
     {
         TypeHelper<T0, T1, T2, T3, T4>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Run(ref this, callback);
     }
 
@@ -23,6 +24,7 @@ public void Run(Ecs.RunCallback callback)
     public void Run(delegate*<Iter, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Run(ref this, callback);
     }
 
@@ -33,6 +35,7 @@ public void Run(delegate*<Iter, void> callback)
     public void Iter(Ecs.IterFieldCallback<T0, T1, T2, T3, T4> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -43,6 +46,7 @@ public void Iter(Ecs.IterFieldCallback<T0, T1, T2, T3, T4> callback)
     public void Iter(Ecs.IterSpanCallback<T0, T1, T2, T3, T4> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -53,6 +57,7 @@ public void Iter(Ecs.IterSpanCallback<T0, T1, T2, T3, T4> callback)
     public void Iter(Ecs.IterPointerCallback<T0, T1, T2, T3, T4> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -63,6 +68,7 @@ public void Iter(Ecs.IterPointerCallback<T0, T1, T2, T3, T4> callback)
     public void Iter(delegate*<Iter, Field<T0>, Field<T1>, Field<T2>, Field<T3>, Field<T4>, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -73,6 +79,7 @@ public void Iter(delegate*<Iter, Field<T0>, Field<T1>, Field<T2>, Field<T3>, Fie
     public void Iter(delegate*<Iter, Span<T0>, Span<T1>, Span<T2>, Span<T3>, Span<T4>, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -83,6 +90,7 @@ public void Iter(delegate*<Iter, Span<T0>, Span<T1>, Span<T2>, Span<T3>, Span<T4
     public void Iter(delegate*<Iter, T0*, T1*, T2*, T3*, T4*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -93,6 +101,7 @@ public void Iter(delegate*<Iter, T0*, T1*, T2*, T3*, T4*, void> callback)
     public void Each(Ecs.EachRefCallback<T0, T1, T2, T3, T4> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -103,6 +112,7 @@ public void Each(Ecs.EachRefCallback<T0, T1, T2, T3, T4> callback)
     public void Each(Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -113,6 +123,7 @@ public void Each(Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4> callback)
     public void Each(Ecs.EachIterRefCallback<T0, T1, T2, T3, T4> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -123,6 +134,7 @@ public void Each(Ecs.EachIterRefCallback<T0, T1, T2, T3, T4> callback)
     public void Each(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -133,6 +145,7 @@ public void Each(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, void> callbac
     public void Each(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -143,6 +156,7 @@ public void Each(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, void>
     public void Each(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -153,6 +167,7 @@ public void Each(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, vo
     public void Each(Ecs.EachPointerCallback<T0, T1, T2, T3, T4> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -163,6 +178,7 @@ public void Each(Ecs.EachPointerCallback<T0, T1, T2, T3, T4> callback)
     public void Each(Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -173,6 +189,7 @@ public void Each(Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4> callback)
     public void Each(Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -183,6 +200,7 @@ public void Each(Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4> callback)
     public void Each(delegate*<T0*, T1*, T2*, T3*, T4*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -193,6 +211,7 @@ public void Each(delegate*<T0*, T1*, T2*, T3*, T4*, void> callback)
     public void Each(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -203,6 +222,7 @@ public void Each(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, void> callback)
     public void Each(delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -213,6 +233,7 @@ public void Each(delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, void> callback)
     public Entity Find(Ecs.FindRefCallback<T0, T1, T2, T3, T4> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -223,6 +244,7 @@ public Entity Find(Ecs.FindRefCallback<T0, T1, T2, T3, T4> callback)
     public Entity Find(Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -233,6 +255,7 @@ public Entity Find(Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4> callback)
     public Entity Find(Ecs.FindIterRefCallback<T0, T1, T2, T3, T4> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -243,6 +266,7 @@ public Entity Find(Ecs.FindIterRefCallback<T0, T1, T2, T3, T4> callback)
     public Entity Find(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -253,6 +277,7 @@ public Entity Find(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, bool> callb
     public Entity Find(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -263,6 +288,7 @@ public Entity Find(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, boo
     public Entity Find(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -273,6 +299,7 @@ public Entity Find(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4,
     public Entity Find(Ecs.FindPointerCallback<T0, T1, T2, T3, T4> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -283,6 +310,7 @@ public Entity Find(Ecs.FindPointerCallback<T0, T1, T2, T3, T4> callback)
     public Entity Find(Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -293,6 +321,7 @@ public Entity Find(Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4> callback)
     public Entity Find(Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -303,6 +332,7 @@ public Entity Find(Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4> callback)
     public Entity Find(delegate*<T0*, T1*, T2*, T3*, T4*, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -313,6 +343,7 @@ public Entity Find(delegate*<T0*, T1*, T2*, T3*, T4*, bool> callback)
     public Entity Find(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -323,6 +354,7 @@ public Entity Find(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, bool> callback)
     public Entity Find(delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 }
\ No newline at end of file
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/PageIterable/PageIterable.IIterable/T6.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/PageIterable/PageIterable.IIterable/T6.g.cs
index 9a452a55..4d9491b0 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/PageIterable/PageIterable.IIterable/T6.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/PageIterable/PageIterable.IIterable/T6.g.cs
@@ -13,6 +13,7 @@ public unsafe partial struct PageIterable<T0, T1, T2, T3, T4, T5>
     public void Run(Ecs.RunCallback callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Run(ref this, callback);
     }
 
@@ -23,6 +24,7 @@ public void Run(Ecs.RunCallback callback)
     public void Run(delegate*<Iter, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Run(ref this, callback);
     }
 
@@ -33,6 +35,7 @@ public void Run(delegate*<Iter, void> callback)
     public void Iter(Ecs.IterFieldCallback<T0, T1, T2, T3, T4, T5> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -43,6 +46,7 @@ public void Iter(Ecs.IterFieldCallback<T0, T1, T2, T3, T4, T5> callback)
     public void Iter(Ecs.IterSpanCallback<T0, T1, T2, T3, T4, T5> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -53,6 +57,7 @@ public void Iter(Ecs.IterSpanCallback<T0, T1, T2, T3, T4, T5> callback)
     public void Iter(Ecs.IterPointerCallback<T0, T1, T2, T3, T4, T5> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -63,6 +68,7 @@ public void Iter(Ecs.IterPointerCallback<T0, T1, T2, T3, T4, T5> callback)
     public void Iter(delegate*<Iter, Field<T0>, Field<T1>, Field<T2>, Field<T3>, Field<T4>, Field<T5>, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -73,6 +79,7 @@ public void Iter(delegate*<Iter, Field<T0>, Field<T1>, Field<T2>, Field<T3>, Fie
     public void Iter(delegate*<Iter, Span<T0>, Span<T1>, Span<T2>, Span<T3>, Span<T4>, Span<T5>, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -83,6 +90,7 @@ public void Iter(delegate*<Iter, Span<T0>, Span<T1>, Span<T2>, Span<T3>, Span<T4
     public void Iter(delegate*<Iter, T0*, T1*, T2*, T3*, T4*, T5*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -93,6 +101,7 @@ public void Iter(delegate*<Iter, T0*, T1*, T2*, T3*, T4*, T5*, void> callback)
     public void Each(Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -103,6 +112,7 @@ public void Each(Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5> callback)
     public void Each(Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -113,6 +123,7 @@ public void Each(Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5> callback)
     public void Each(Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -123,6 +134,7 @@ public void Each(Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5> callback)
     public void Each(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -133,6 +145,7 @@ public void Each(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, void>
     public void Each(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -143,6 +156,7 @@ public void Each(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T
     public void Each(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -153,6 +167,7 @@ public void Each(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, re
     public void Each(Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -163,6 +178,7 @@ public void Each(Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5> callback)
     public void Each(Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -173,6 +189,7 @@ public void Each(Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5> callback)
     public void Each(Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -183,6 +200,7 @@ public void Each(Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5> callback)
     public void Each(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -193,6 +211,7 @@ public void Each(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, void> callback)
     public void Each(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -203,6 +222,7 @@ public void Each(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, void> callback)
     public void Each(delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -213,6 +233,7 @@ public void Each(delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, void> callba
     public Entity Find(Ecs.FindRefCallback<T0, T1, T2, T3, T4, T5> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -223,6 +244,7 @@ public Entity Find(Ecs.FindRefCallback<T0, T1, T2, T3, T4, T5> callback)
     public Entity Find(Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4, T5> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -233,6 +255,7 @@ public Entity Find(Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4, T5> callback)
     public Entity Find(Ecs.FindIterRefCallback<T0, T1, T2, T3, T4, T5> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -243,6 +266,7 @@ public Entity Find(Ecs.FindIterRefCallback<T0, T1, T2, T3, T4, T5> callback)
     public Entity Find(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -253,6 +277,7 @@ public Entity Find(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, boo
     public Entity Find(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -263,6 +288,7 @@ public Entity Find(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref
     public Entity Find(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -273,6 +299,7 @@ public Entity Find(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4,
     public Entity Find(Ecs.FindPointerCallback<T0, T1, T2, T3, T4, T5> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -283,6 +310,7 @@ public Entity Find(Ecs.FindPointerCallback<T0, T1, T2, T3, T4, T5> callback)
     public Entity Find(Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4, T5> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -293,6 +321,7 @@ public Entity Find(Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4, T5> callbac
     public Entity Find(Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4, T5> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -303,6 +332,7 @@ public Entity Find(Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4, T5> callback)
     public Entity Find(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -313,6 +343,7 @@ public Entity Find(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, bool> callback)
     public Entity Find(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -323,6 +354,7 @@ public Entity Find(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, bool> callbac
     public Entity Find(delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 }
\ No newline at end of file
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/PageIterable/PageIterable.IIterable/T7.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/PageIterable/PageIterable.IIterable/T7.g.cs
index de5dde72..2e838fff 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/PageIterable/PageIterable.IIterable/T7.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/PageIterable/PageIterable.IIterable/T7.g.cs
@@ -13,6 +13,7 @@ public unsafe partial struct PageIterable<T0, T1, T2, T3, T4, T5, T6>
     public void Run(Ecs.RunCallback callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Run(ref this, callback);
     }
 
@@ -23,6 +24,7 @@ public void Run(Ecs.RunCallback callback)
     public void Run(delegate*<Iter, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Run(ref this, callback);
     }
 
@@ -33,6 +35,7 @@ public void Run(delegate*<Iter, void> callback)
     public void Iter(Ecs.IterFieldCallback<T0, T1, T2, T3, T4, T5, T6> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -43,6 +46,7 @@ public void Iter(Ecs.IterFieldCallback<T0, T1, T2, T3, T4, T5, T6> callback)
     public void Iter(Ecs.IterSpanCallback<T0, T1, T2, T3, T4, T5, T6> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -53,6 +57,7 @@ public void Iter(Ecs.IterSpanCallback<T0, T1, T2, T3, T4, T5, T6> callback)
     public void Iter(Ecs.IterPointerCallback<T0, T1, T2, T3, T4, T5, T6> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -63,6 +68,7 @@ public void Iter(Ecs.IterPointerCallback<T0, T1, T2, T3, T4, T5, T6> callback)
     public void Iter(delegate*<Iter, Field<T0>, Field<T1>, Field<T2>, Field<T3>, Field<T4>, Field<T5>, Field<T6>, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -73,6 +79,7 @@ public void Iter(delegate*<Iter, Field<T0>, Field<T1>, Field<T2>, Field<T3>, Fie
     public void Iter(delegate*<Iter, Span<T0>, Span<T1>, Span<T2>, Span<T3>, Span<T4>, Span<T5>, Span<T6>, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -83,6 +90,7 @@ public void Iter(delegate*<Iter, Span<T0>, Span<T1>, Span<T2>, Span<T3>, Span<T4
     public void Iter(delegate*<Iter, T0*, T1*, T2*, T3*, T4*, T5*, T6*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -93,6 +101,7 @@ public void Iter(delegate*<Iter, T0*, T1*, T2*, T3*, T4*, T5*, T6*, void> callba
     public void Each(Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5, T6> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -103,6 +112,7 @@ public void Each(Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5, T6> callback)
     public void Each(Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5, T6> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -113,6 +123,7 @@ public void Each(Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5, T6> callback)
     public void Each(Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5, T6> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -123,6 +134,7 @@ public void Each(Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5, T6> callback)
     public void Each(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -133,6 +145,7 @@ public void Each(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T
     public void Each(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -143,6 +156,7 @@ public void Each(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T
     public void Each(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -153,6 +167,7 @@ public void Each(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, re
     public void Each(Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5, T6> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -163,6 +178,7 @@ public void Each(Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5, T6> callback)
     public void Each(Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -173,6 +189,7 @@ public void Each(Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6> callb
     public void Each(Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5, T6> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -183,6 +200,7 @@ public void Each(Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5, T6> callbac
     public void Each(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -193,6 +211,7 @@ public void Each(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, void> callback)
     public void Each(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -203,6 +222,7 @@ public void Each(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, void> call
     public void Each(delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -213,6 +233,7 @@ public void Each(delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, void> c
     public Entity Find(Ecs.FindRefCallback<T0, T1, T2, T3, T4, T5, T6> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -223,6 +244,7 @@ public Entity Find(Ecs.FindRefCallback<T0, T1, T2, T3, T4, T5, T6> callback)
     public Entity Find(Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4, T5, T6> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -233,6 +255,7 @@ public Entity Find(Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4, T5, T6> callbac
     public Entity Find(Ecs.FindIterRefCallback<T0, T1, T2, T3, T4, T5, T6> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -243,6 +266,7 @@ public Entity Find(Ecs.FindIterRefCallback<T0, T1, T2, T3, T4, T5, T6> callback)
     public Entity Find(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -253,6 +277,7 @@ public Entity Find(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref
     public Entity Find(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -263,6 +288,7 @@ public Entity Find(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref
     public Entity Find(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -273,6 +299,7 @@ public Entity Find(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4,
     public Entity Find(Ecs.FindPointerCallback<T0, T1, T2, T3, T4, T5, T6> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -283,6 +310,7 @@ public Entity Find(Ecs.FindPointerCallback<T0, T1, T2, T3, T4, T5, T6> callback)
     public Entity Find(Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -293,6 +321,7 @@ public Entity Find(Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6> cal
     public Entity Find(Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4, T5, T6> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -303,6 +332,7 @@ public Entity Find(Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4, T5, T6> callb
     public Entity Find(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -313,6 +343,7 @@ public Entity Find(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, bool> callback)
     public Entity Find(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -323,6 +354,7 @@ public Entity Find(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, bool> ca
     public Entity Find(delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 }
\ No newline at end of file
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/PageIterable/PageIterable.IIterable/T8.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/PageIterable/PageIterable.IIterable/T8.g.cs
index 5eda67f3..3c5f8ab8 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/PageIterable/PageIterable.IIterable/T8.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/PageIterable/PageIterable.IIterable/T8.g.cs
@@ -13,6 +13,7 @@ public unsafe partial struct PageIterable<T0, T1, T2, T3, T4, T5, T6, T7>
     public void Run(Ecs.RunCallback callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Run(ref this, callback);
     }
 
@@ -23,6 +24,7 @@ public void Run(Ecs.RunCallback callback)
     public void Run(delegate*<Iter, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Run(ref this, callback);
     }
 
@@ -33,6 +35,7 @@ public void Run(delegate*<Iter, void> callback)
     public void Iter(Ecs.IterFieldCallback<T0, T1, T2, T3, T4, T5, T6, T7> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -43,6 +46,7 @@ public void Iter(Ecs.IterFieldCallback<T0, T1, T2, T3, T4, T5, T6, T7> callback)
     public void Iter(Ecs.IterSpanCallback<T0, T1, T2, T3, T4, T5, T6, T7> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -53,6 +57,7 @@ public void Iter(Ecs.IterSpanCallback<T0, T1, T2, T3, T4, T5, T6, T7> callback)
     public void Iter(Ecs.IterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -63,6 +68,7 @@ public void Iter(Ecs.IterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7> callbac
     public void Iter(delegate*<Iter, Field<T0>, Field<T1>, Field<T2>, Field<T3>, Field<T4>, Field<T5>, Field<T6>, Field<T7>, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -73,6 +79,7 @@ public void Iter(delegate*<Iter, Field<T0>, Field<T1>, Field<T2>, Field<T3>, Fie
     public void Iter(delegate*<Iter, Span<T0>, Span<T1>, Span<T2>, Span<T3>, Span<T4>, Span<T5>, Span<T6>, Span<T7>, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -83,6 +90,7 @@ public void Iter(delegate*<Iter, Span<T0>, Span<T1>, Span<T2>, Span<T3>, Span<T4
     public void Iter(delegate*<Iter, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -93,6 +101,7 @@ public void Iter(delegate*<Iter, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, void> c
     public void Each(Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5, T6, T7> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -103,6 +112,7 @@ public void Each(Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5, T6, T7> callback)
     public void Each(Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -113,6 +123,7 @@ public void Each(Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7> callb
     public void Each(Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -123,6 +134,7 @@ public void Each(Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7> callbac
     public void Each(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -133,6 +145,7 @@ public void Each(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T
     public void Each(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -143,6 +156,7 @@ public void Each(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T
     public void Each(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -153,6 +167,7 @@ public void Each(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, re
     public void Each(Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -163,6 +178,7 @@ public void Each(Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7> callbac
     public void Each(Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -173,6 +189,7 @@ public void Each(Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7> c
     public void Each(Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -183,6 +200,7 @@ public void Each(Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7> cal
     public void Each(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -193,6 +211,7 @@ public void Each(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, void> callbac
     public void Each(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -203,6 +222,7 @@ public void Each(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, void>
     public void Each(delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -213,6 +233,7 @@ public void Each(delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, vo
     public Entity Find(Ecs.FindRefCallback<T0, T1, T2, T3, T4, T5, T6, T7> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -223,6 +244,7 @@ public Entity Find(Ecs.FindRefCallback<T0, T1, T2, T3, T4, T5, T6, T7> callback)
     public Entity Find(Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -233,6 +255,7 @@ public Entity Find(Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7> cal
     public Entity Find(Ecs.FindIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -243,6 +266,7 @@ public Entity Find(Ecs.FindIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7> callb
     public Entity Find(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -253,6 +277,7 @@ public Entity Find(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref
     public Entity Find(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -263,6 +288,7 @@ public Entity Find(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref
     public Entity Find(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -273,6 +299,7 @@ public Entity Find(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4,
     public Entity Find(Ecs.FindPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -283,6 +310,7 @@ public Entity Find(Ecs.FindPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7> callb
     public Entity Find(Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -293,6 +321,7 @@ public Entity Find(Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7>
     public Entity Find(Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -303,6 +332,7 @@ public Entity Find(Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7> c
     public Entity Find(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -313,6 +343,7 @@ public Entity Find(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, bool> callb
     public Entity Find(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -323,6 +354,7 @@ public Entity Find(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, boo
     public Entity Find(delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 }
\ No newline at end of file
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/PageIterable/PageIterable.IIterable/T9.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/PageIterable/PageIterable.IIterable/T9.g.cs
index 7457ee74..9f41c3e8 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/PageIterable/PageIterable.IIterable/T9.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/PageIterable/PageIterable.IIterable/T9.g.cs
@@ -13,6 +13,7 @@ public unsafe partial struct PageIterable<T0, T1, T2, T3, T4, T5, T6, T7, T8>
     public void Run(Ecs.RunCallback callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Run(ref this, callback);
     }
 
@@ -23,6 +24,7 @@ public void Run(Ecs.RunCallback callback)
     public void Run(delegate*<Iter, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Run(ref this, callback);
     }
 
@@ -33,6 +35,7 @@ public void Run(delegate*<Iter, void> callback)
     public void Iter(Ecs.IterFieldCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -43,6 +46,7 @@ public void Iter(Ecs.IterFieldCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> callb
     public void Iter(Ecs.IterSpanCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -53,6 +57,7 @@ public void Iter(Ecs.IterSpanCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> callba
     public void Iter(Ecs.IterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -63,6 +68,7 @@ public void Iter(Ecs.IterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> cal
     public void Iter(delegate*<Iter, Field<T0>, Field<T1>, Field<T2>, Field<T3>, Field<T4>, Field<T5>, Field<T6>, Field<T7>, Field<T8>, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -73,6 +79,7 @@ public void Iter(delegate*<Iter, Field<T0>, Field<T1>, Field<T2>, Field<T3>, Fie
     public void Iter(delegate*<Iter, Span<T0>, Span<T1>, Span<T2>, Span<T3>, Span<T4>, Span<T5>, Span<T6>, Span<T7>, Span<T8>, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -83,6 +90,7 @@ public void Iter(delegate*<Iter, Span<T0>, Span<T1>, Span<T2>, Span<T3>, Span<T4
     public void Iter(delegate*<Iter, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -93,6 +101,7 @@ public void Iter(delegate*<Iter, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, vo
     public void Each(Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -103,6 +112,7 @@ public void Each(Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> callbac
     public void Each(Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -113,6 +123,7 @@ public void Each(Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> c
     public void Each(Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -123,6 +134,7 @@ public void Each(Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> cal
     public void Each(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -133,6 +145,7 @@ public void Each(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T
     public void Each(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -143,6 +156,7 @@ public void Each(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T
     public void Each(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -153,6 +167,7 @@ public void Each(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, re
     public void Each(Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -163,6 +178,7 @@ public void Each(Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> cal
     public void Each(Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -173,6 +189,7 @@ public void Each(Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T
     public void Each(Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -183,6 +200,7 @@ public void Each(Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8>
     public void Each(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -193,6 +211,7 @@ public void Each(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, void> ca
     public void Each(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -203,6 +222,7 @@ public void Each(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*,
     public void Each(delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -213,6 +233,7 @@ public void Each(delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8
     public Entity Find(Ecs.FindRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -223,6 +244,7 @@ public Entity Find(Ecs.FindRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> callb
     public Entity Find(Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -233,6 +255,7 @@ public Entity Find(Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8>
     public Entity Find(Ecs.FindIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -243,6 +266,7 @@ public Entity Find(Ecs.FindIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> c
     public Entity Find(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -253,6 +277,7 @@ public Entity Find(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref
     public Entity Find(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -263,6 +288,7 @@ public Entity Find(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref
     public Entity Find(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -273,6 +299,7 @@ public Entity Find(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4,
     public Entity Find(Ecs.FindPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -283,6 +310,7 @@ public Entity Find(Ecs.FindPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> c
     public Entity Find(Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -293,6 +321,7 @@ public Entity Find(Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7,
     public Entity Find(Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -303,6 +332,7 @@ public Entity Find(Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T
     public Entity Find(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -313,6 +343,7 @@ public Entity Find(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, bool>
     public Entity Find(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -323,6 +354,7 @@ public Entity Find(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*
     public Entity Find(delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 }
\ No newline at end of file
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/PageIterable/PageIterable/T1.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/PageIterable/PageIterable/T1.g.cs
index 3670bf1c..2840eee9 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/PageIterable/PageIterable/T1.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/PageIterable/PageIterable/T1.g.cs
@@ -63,6 +63,9 @@ public override int GetHashCode()
 // IIterableBase Interface
 public unsafe partial struct PageIterable<T0> : IIterableBase
 {
+    /// <inheritdoc cref="PageIterable.World"/>
+    public ref ecs_world_t* World => ref _pageIterable.World;
+
     /// <inheritdoc cref="PageIterable.GetIter(ecs_world_t*)"/>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public ecs_iter_t GetIter(ecs_world_t* world = null)
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/PageIterable/PageIterable/T10.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/PageIterable/PageIterable/T10.g.cs
index b24dac42..38b86154 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/PageIterable/PageIterable/T10.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/PageIterable/PageIterable/T10.g.cs
@@ -63,6 +63,9 @@ public override int GetHashCode()
 // IIterableBase Interface
 public unsafe partial struct PageIterable<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> : IIterableBase
 {
+    /// <inheritdoc cref="PageIterable.World"/>
+    public ref ecs_world_t* World => ref _pageIterable.World;
+
     /// <inheritdoc cref="PageIterable.GetIter(ecs_world_t*)"/>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public ecs_iter_t GetIter(ecs_world_t* world = null)
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/PageIterable/PageIterable/T11.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/PageIterable/PageIterable/T11.g.cs
index 2c03c439..8099e2de 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/PageIterable/PageIterable/T11.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/PageIterable/PageIterable/T11.g.cs
@@ -63,6 +63,9 @@ public override int GetHashCode()
 // IIterableBase Interface
 public unsafe partial struct PageIterable<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> : IIterableBase
 {
+    /// <inheritdoc cref="PageIterable.World"/>
+    public ref ecs_world_t* World => ref _pageIterable.World;
+
     /// <inheritdoc cref="PageIterable.GetIter(ecs_world_t*)"/>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public ecs_iter_t GetIter(ecs_world_t* world = null)
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/PageIterable/PageIterable/T12.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/PageIterable/PageIterable/T12.g.cs
index 8bc8c36a..3dd27446 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/PageIterable/PageIterable/T12.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/PageIterable/PageIterable/T12.g.cs
@@ -63,6 +63,9 @@ public override int GetHashCode()
 // IIterableBase Interface
 public unsafe partial struct PageIterable<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> : IIterableBase
 {
+    /// <inheritdoc cref="PageIterable.World"/>
+    public ref ecs_world_t* World => ref _pageIterable.World;
+
     /// <inheritdoc cref="PageIterable.GetIter(ecs_world_t*)"/>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public ecs_iter_t GetIter(ecs_world_t* world = null)
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/PageIterable/PageIterable/T13.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/PageIterable/PageIterable/T13.g.cs
index abdd985c..591bb200 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/PageIterable/PageIterable/T13.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/PageIterable/PageIterable/T13.g.cs
@@ -63,6 +63,9 @@ public override int GetHashCode()
 // IIterableBase Interface
 public unsafe partial struct PageIterable<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> : IIterableBase
 {
+    /// <inheritdoc cref="PageIterable.World"/>
+    public ref ecs_world_t* World => ref _pageIterable.World;
+
     /// <inheritdoc cref="PageIterable.GetIter(ecs_world_t*)"/>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public ecs_iter_t GetIter(ecs_world_t* world = null)
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/PageIterable/PageIterable/T14.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/PageIterable/PageIterable/T14.g.cs
index 4de8dff0..66e860ae 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/PageIterable/PageIterable/T14.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/PageIterable/PageIterable/T14.g.cs
@@ -63,6 +63,9 @@ public override int GetHashCode()
 // IIterableBase Interface
 public unsafe partial struct PageIterable<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> : IIterableBase
 {
+    /// <inheritdoc cref="PageIterable.World"/>
+    public ref ecs_world_t* World => ref _pageIterable.World;
+
     /// <inheritdoc cref="PageIterable.GetIter(ecs_world_t*)"/>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public ecs_iter_t GetIter(ecs_world_t* world = null)
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/PageIterable/PageIterable/T15.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/PageIterable/PageIterable/T15.g.cs
index 59312020..7c3d5b83 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/PageIterable/PageIterable/T15.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/PageIterable/PageIterable/T15.g.cs
@@ -63,6 +63,9 @@ public override int GetHashCode()
 // IIterableBase Interface
 public unsafe partial struct PageIterable<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> : IIterableBase
 {
+    /// <inheritdoc cref="PageIterable.World"/>
+    public ref ecs_world_t* World => ref _pageIterable.World;
+
     /// <inheritdoc cref="PageIterable.GetIter(ecs_world_t*)"/>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public ecs_iter_t GetIter(ecs_world_t* world = null)
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/PageIterable/PageIterable/T16.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/PageIterable/PageIterable/T16.g.cs
index b0c9b096..301f9bb1 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/PageIterable/PageIterable/T16.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/PageIterable/PageIterable/T16.g.cs
@@ -63,6 +63,9 @@ public override int GetHashCode()
 // IIterableBase Interface
 public unsafe partial struct PageIterable<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> : IIterableBase
 {
+    /// <inheritdoc cref="PageIterable.World"/>
+    public ref ecs_world_t* World => ref _pageIterable.World;
+
     /// <inheritdoc cref="PageIterable.GetIter(ecs_world_t*)"/>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public ecs_iter_t GetIter(ecs_world_t* world = null)
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/PageIterable/PageIterable/T2.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/PageIterable/PageIterable/T2.g.cs
index b08bab02..bc0e6145 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/PageIterable/PageIterable/T2.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/PageIterable/PageIterable/T2.g.cs
@@ -63,6 +63,9 @@ public override int GetHashCode()
 // IIterableBase Interface
 public unsafe partial struct PageIterable<T0, T1> : IIterableBase
 {
+    /// <inheritdoc cref="PageIterable.World"/>
+    public ref ecs_world_t* World => ref _pageIterable.World;
+
     /// <inheritdoc cref="PageIterable.GetIter(ecs_world_t*)"/>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public ecs_iter_t GetIter(ecs_world_t* world = null)
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/PageIterable/PageIterable/T3.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/PageIterable/PageIterable/T3.g.cs
index 8f81240c..453c0684 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/PageIterable/PageIterable/T3.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/PageIterable/PageIterable/T3.g.cs
@@ -63,6 +63,9 @@ public override int GetHashCode()
 // IIterableBase Interface
 public unsafe partial struct PageIterable<T0, T1, T2> : IIterableBase
 {
+    /// <inheritdoc cref="PageIterable.World"/>
+    public ref ecs_world_t* World => ref _pageIterable.World;
+
     /// <inheritdoc cref="PageIterable.GetIter(ecs_world_t*)"/>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public ecs_iter_t GetIter(ecs_world_t* world = null)
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/PageIterable/PageIterable/T4.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/PageIterable/PageIterable/T4.g.cs
index fec43310..c77507f3 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/PageIterable/PageIterable/T4.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/PageIterable/PageIterable/T4.g.cs
@@ -63,6 +63,9 @@ public override int GetHashCode()
 // IIterableBase Interface
 public unsafe partial struct PageIterable<T0, T1, T2, T3> : IIterableBase
 {
+    /// <inheritdoc cref="PageIterable.World"/>
+    public ref ecs_world_t* World => ref _pageIterable.World;
+
     /// <inheritdoc cref="PageIterable.GetIter(ecs_world_t*)"/>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public ecs_iter_t GetIter(ecs_world_t* world = null)
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/PageIterable/PageIterable/T5.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/PageIterable/PageIterable/T5.g.cs
index dd421277..c865c1fa 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/PageIterable/PageIterable/T5.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/PageIterable/PageIterable/T5.g.cs
@@ -63,6 +63,9 @@ public override int GetHashCode()
 // IIterableBase Interface
 public unsafe partial struct PageIterable<T0, T1, T2, T3, T4> : IIterableBase
 {
+    /// <inheritdoc cref="PageIterable.World"/>
+    public ref ecs_world_t* World => ref _pageIterable.World;
+
     /// <inheritdoc cref="PageIterable.GetIter(ecs_world_t*)"/>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public ecs_iter_t GetIter(ecs_world_t* world = null)
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/PageIterable/PageIterable/T6.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/PageIterable/PageIterable/T6.g.cs
index 9cba2b63..a105549b 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/PageIterable/PageIterable/T6.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/PageIterable/PageIterable/T6.g.cs
@@ -63,6 +63,9 @@ public override int GetHashCode()
 // IIterableBase Interface
 public unsafe partial struct PageIterable<T0, T1, T2, T3, T4, T5> : IIterableBase
 {
+    /// <inheritdoc cref="PageIterable.World"/>
+    public ref ecs_world_t* World => ref _pageIterable.World;
+
     /// <inheritdoc cref="PageIterable.GetIter(ecs_world_t*)"/>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public ecs_iter_t GetIter(ecs_world_t* world = null)
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/PageIterable/PageIterable/T7.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/PageIterable/PageIterable/T7.g.cs
index d5d877f4..09cd8514 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/PageIterable/PageIterable/T7.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/PageIterable/PageIterable/T7.g.cs
@@ -63,6 +63,9 @@ public override int GetHashCode()
 // IIterableBase Interface
 public unsafe partial struct PageIterable<T0, T1, T2, T3, T4, T5, T6> : IIterableBase
 {
+    /// <inheritdoc cref="PageIterable.World"/>
+    public ref ecs_world_t* World => ref _pageIterable.World;
+
     /// <inheritdoc cref="PageIterable.GetIter(ecs_world_t*)"/>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public ecs_iter_t GetIter(ecs_world_t* world = null)
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/PageIterable/PageIterable/T8.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/PageIterable/PageIterable/T8.g.cs
index 22bb63b3..2493e347 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/PageIterable/PageIterable/T8.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/PageIterable/PageIterable/T8.g.cs
@@ -63,6 +63,9 @@ public override int GetHashCode()
 // IIterableBase Interface
 public unsafe partial struct PageIterable<T0, T1, T2, T3, T4, T5, T6, T7> : IIterableBase
 {
+    /// <inheritdoc cref="PageIterable.World"/>
+    public ref ecs_world_t* World => ref _pageIterable.World;
+
     /// <inheritdoc cref="PageIterable.GetIter(ecs_world_t*)"/>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public ecs_iter_t GetIter(ecs_world_t* world = null)
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/PageIterable/PageIterable/T9.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/PageIterable/PageIterable/T9.g.cs
index fa196c0a..bb67ab32 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/PageIterable/PageIterable/T9.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/PageIterable/PageIterable/T9.g.cs
@@ -63,6 +63,9 @@ public override int GetHashCode()
 // IIterableBase Interface
 public unsafe partial struct PageIterable<T0, T1, T2, T3, T4, T5, T6, T7, T8> : IIterableBase
 {
+    /// <inheritdoc cref="PageIterable.World"/>
+    public ref ecs_world_t* World => ref _pageIterable.World;
+
     /// <inheritdoc cref="PageIterable.GetIter(ecs_world_t*)"/>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public ecs_iter_t GetIter(ecs_world_t* world = null)
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/Query/Query.IIterable/T1.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/Query/Query.IIterable/T1.g.cs
index b5416bb6..cd80d439 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/Query/Query.IIterable/T1.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/Query/Query.IIterable/T1.g.cs
@@ -13,6 +13,7 @@ public unsafe partial struct Query<T0>
     public void Run(Ecs.RunCallback callback)
     {
         TypeHelper<T0>.AssertReferenceTypes(true);
+        TypeHelper<T0>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Run(ref this, callback);
     }
 
@@ -23,6 +24,7 @@ public void Run(Ecs.RunCallback callback)
     public void Run(delegate*<Iter, void> callback)
     {
         TypeHelper<T0>.AssertReferenceTypes(true);
+        TypeHelper<T0>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Run(ref this, callback);
     }
 
@@ -33,6 +35,7 @@ public void Run(delegate*<Iter, void> callback)
     public void Iter(Ecs.IterFieldCallback<T0> callback)
     {
         TypeHelper<T0>.AssertReferenceTypes(true);
+        TypeHelper<T0>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -43,6 +46,7 @@ public void Iter(Ecs.IterFieldCallback<T0> callback)
     public void Iter(Ecs.IterSpanCallback<T0> callback)
     {
         TypeHelper<T0>.AssertReferenceTypes(false);
+        TypeHelper<T0>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -53,6 +57,7 @@ public void Iter(Ecs.IterSpanCallback<T0> callback)
     public void Iter(Ecs.IterPointerCallback<T0> callback)
     {
         TypeHelper<T0>.AssertReferenceTypes(false);
+        TypeHelper<T0>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -63,6 +68,7 @@ public void Iter(Ecs.IterPointerCallback<T0> callback)
     public void Iter(delegate*<Iter, Field<T0>, void> callback)
     {
         TypeHelper<T0>.AssertReferenceTypes(true);
+        TypeHelper<T0>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -73,6 +79,7 @@ public void Iter(delegate*<Iter, Field<T0>, void> callback)
     public void Iter(delegate*<Iter, Span<T0>, void> callback)
     {
         TypeHelper<T0>.AssertReferenceTypes(false);
+        TypeHelper<T0>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -83,6 +90,7 @@ public void Iter(delegate*<Iter, Span<T0>, void> callback)
     public void Iter(delegate*<Iter, T0*, void> callback)
     {
         TypeHelper<T0>.AssertReferenceTypes(false);
+        TypeHelper<T0>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -93,6 +101,7 @@ public void Iter(delegate*<Iter, T0*, void> callback)
     public void Each(Ecs.EachRefCallback<T0> callback)
     {
         TypeHelper<T0>.AssertReferenceTypes(true);
+        TypeHelper<T0>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -103,6 +112,7 @@ public void Each(Ecs.EachRefCallback<T0> callback)
     public void Each(Ecs.EachEntityRefCallback<T0> callback)
     {
         TypeHelper<T0>.AssertReferenceTypes(true);
+        TypeHelper<T0>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -113,6 +123,7 @@ public void Each(Ecs.EachEntityRefCallback<T0> callback)
     public void Each(Ecs.EachIterRefCallback<T0> callback)
     {
         TypeHelper<T0>.AssertReferenceTypes(true);
+        TypeHelper<T0>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -123,6 +134,7 @@ public void Each(Ecs.EachIterRefCallback<T0> callback)
     public void Each(delegate*<ref T0, void> callback)
     {
         TypeHelper<T0>.AssertReferenceTypes(true);
+        TypeHelper<T0>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -133,6 +145,7 @@ public void Each(delegate*<ref T0, void> callback)
     public void Each(delegate*<Entity, ref T0, void> callback)
     {
         TypeHelper<T0>.AssertReferenceTypes(true);
+        TypeHelper<T0>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -143,6 +156,7 @@ public void Each(delegate*<Entity, ref T0, void> callback)
     public void Each(delegate*<Iter, int, ref T0, void> callback)
     {
         TypeHelper<T0>.AssertReferenceTypes(true);
+        TypeHelper<T0>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -153,6 +167,7 @@ public void Each(delegate*<Iter, int, ref T0, void> callback)
     public void Each(Ecs.EachPointerCallback<T0> callback)
     {
         TypeHelper<T0>.AssertReferenceTypes(false);
+        TypeHelper<T0>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -163,6 +178,7 @@ public void Each(Ecs.EachPointerCallback<T0> callback)
     public void Each(Ecs.EachEntityPointerCallback<T0> callback)
     {
         TypeHelper<T0>.AssertReferenceTypes(false);
+        TypeHelper<T0>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -173,6 +189,7 @@ public void Each(Ecs.EachEntityPointerCallback<T0> callback)
     public void Each(Ecs.EachIterPointerCallback<T0> callback)
     {
         TypeHelper<T0>.AssertReferenceTypes(false);
+        TypeHelper<T0>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -183,6 +200,7 @@ public void Each(Ecs.EachIterPointerCallback<T0> callback)
     public void Each(delegate*<T0*, void> callback)
     {
         TypeHelper<T0>.AssertReferenceTypes(false);
+        TypeHelper<T0>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -193,6 +211,7 @@ public void Each(delegate*<T0*, void> callback)
     public void Each(delegate*<Entity, T0*, void> callback)
     {
         TypeHelper<T0>.AssertReferenceTypes(false);
+        TypeHelper<T0>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -203,6 +222,7 @@ public void Each(delegate*<Entity, T0*, void> callback)
     public void Each(delegate*<Iter, int, T0*, void> callback)
     {
         TypeHelper<T0>.AssertReferenceTypes(false);
+        TypeHelper<T0>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -213,6 +233,7 @@ public void Each(delegate*<Iter, int, T0*, void> callback)
     public Entity Find(Ecs.FindRefCallback<T0> callback)
     {
         TypeHelper<T0>.AssertReferenceTypes(true);
+        TypeHelper<T0>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -223,6 +244,7 @@ public Entity Find(Ecs.FindRefCallback<T0> callback)
     public Entity Find(Ecs.FindEntityRefCallback<T0> callback)
     {
         TypeHelper<T0>.AssertReferenceTypes(true);
+        TypeHelper<T0>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -233,6 +255,7 @@ public Entity Find(Ecs.FindEntityRefCallback<T0> callback)
     public Entity Find(Ecs.FindIterRefCallback<T0> callback)
     {
         TypeHelper<T0>.AssertReferenceTypes(true);
+        TypeHelper<T0>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -243,6 +266,7 @@ public Entity Find(Ecs.FindIterRefCallback<T0> callback)
     public Entity Find(delegate*<ref T0, bool> callback)
     {
         TypeHelper<T0>.AssertReferenceTypes(true);
+        TypeHelper<T0>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -253,6 +277,7 @@ public Entity Find(delegate*<ref T0, bool> callback)
     public Entity Find(delegate*<Entity, ref T0, bool> callback)
     {
         TypeHelper<T0>.AssertReferenceTypes(true);
+        TypeHelper<T0>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -263,6 +288,7 @@ public Entity Find(delegate*<Entity, ref T0, bool> callback)
     public Entity Find(delegate*<Iter, int, ref T0, bool> callback)
     {
         TypeHelper<T0>.AssertReferenceTypes(true);
+        TypeHelper<T0>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -273,6 +299,7 @@ public Entity Find(delegate*<Iter, int, ref T0, bool> callback)
     public Entity Find(Ecs.FindPointerCallback<T0> callback)
     {
         TypeHelper<T0>.AssertReferenceTypes(false);
+        TypeHelper<T0>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -283,6 +310,7 @@ public Entity Find(Ecs.FindPointerCallback<T0> callback)
     public Entity Find(Ecs.FindEntityPointerCallback<T0> callback)
     {
         TypeHelper<T0>.AssertReferenceTypes(false);
+        TypeHelper<T0>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -293,6 +321,7 @@ public Entity Find(Ecs.FindEntityPointerCallback<T0> callback)
     public Entity Find(Ecs.FindIterPointerCallback<T0> callback)
     {
         TypeHelper<T0>.AssertReferenceTypes(false);
+        TypeHelper<T0>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -303,6 +332,7 @@ public Entity Find(Ecs.FindIterPointerCallback<T0> callback)
     public Entity Find(delegate*<T0*, bool> callback)
     {
         TypeHelper<T0>.AssertReferenceTypes(false);
+        TypeHelper<T0>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -313,6 +343,7 @@ public Entity Find(delegate*<T0*, bool> callback)
     public Entity Find(delegate*<Entity, T0*, bool> callback)
     {
         TypeHelper<T0>.AssertReferenceTypes(false);
+        TypeHelper<T0>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -323,6 +354,7 @@ public Entity Find(delegate*<Entity, T0*, bool> callback)
     public Entity Find(delegate*<Iter, int, T0*, bool> callback)
     {
         TypeHelper<T0>.AssertReferenceTypes(false);
+        TypeHelper<T0>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 }
\ No newline at end of file
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/Query/Query.IIterable/T10.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/Query/Query.IIterable/T10.g.cs
index 11b7fc59..5bd7f477 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/Query/Query.IIterable/T10.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/Query/Query.IIterable/T10.g.cs
@@ -13,6 +13,7 @@ public unsafe partial struct Query<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>
     public void Run(Ecs.RunCallback callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Run(ref this, callback);
     }
 
@@ -23,6 +24,7 @@ public void Run(Ecs.RunCallback callback)
     public void Run(delegate*<Iter, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Run(ref this, callback);
     }
 
@@ -33,6 +35,7 @@ public void Run(delegate*<Iter, void> callback)
     public void Iter(Ecs.IterFieldCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -43,6 +46,7 @@ public void Iter(Ecs.IterFieldCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> c
     public void Iter(Ecs.IterSpanCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -53,6 +57,7 @@ public void Iter(Ecs.IterSpanCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> ca
     public void Iter(Ecs.IterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -63,6 +68,7 @@ public void Iter(Ecs.IterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>
     public void Iter(delegate*<Iter, Field<T0>, Field<T1>, Field<T2>, Field<T3>, Field<T4>, Field<T5>, Field<T6>, Field<T7>, Field<T8>, Field<T9>, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -73,6 +79,7 @@ public void Iter(delegate*<Iter, Field<T0>, Field<T1>, Field<T2>, Field<T3>, Fie
     public void Iter(delegate*<Iter, Span<T0>, Span<T1>, Span<T2>, Span<T3>, Span<T4>, Span<T5>, Span<T6>, Span<T7>, Span<T8>, Span<T9>, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -83,6 +90,7 @@ public void Iter(delegate*<Iter, Span<T0>, Span<T1>, Span<T2>, Span<T3>, Span<T4
     public void Iter(delegate*<Iter, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -93,6 +101,7 @@ public void Iter(delegate*<Iter, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9
     public void Each(Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -103,6 +112,7 @@ public void Each(Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> cal
     public void Each(Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -113,6 +123,7 @@ public void Each(Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T
     public void Each(Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -123,6 +134,7 @@ public void Each(Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>
     public void Each(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -133,6 +145,7 @@ public void Each(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T
     public void Each(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -143,6 +156,7 @@ public void Each(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T
     public void Each(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -153,6 +167,7 @@ public void Each(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, re
     public void Each(Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -163,6 +178,7 @@ public void Each(Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>
     public void Each(Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -173,6 +189,7 @@ public void Each(Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T
     public void Each(Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -183,6 +200,7 @@ public void Each(Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8,
     public void Each(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -193,6 +211,7 @@ public void Each(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, voi
     public void Each(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -203,6 +222,7 @@ public void Each(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*,
     public void Each(delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -213,6 +233,7 @@ public void Each(delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8
     public Entity Find(Ecs.FindRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -223,6 +244,7 @@ public Entity Find(Ecs.FindRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> c
     public Entity Find(Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -233,6 +255,7 @@ public Entity Find(Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8,
     public Entity Find(Ecs.FindIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -243,6 +266,7 @@ public Entity Find(Ecs.FindIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T
     public Entity Find(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -253,6 +277,7 @@ public Entity Find(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref
     public Entity Find(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -263,6 +288,7 @@ public Entity Find(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref
     public Entity Find(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -273,6 +299,7 @@ public Entity Find(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4,
     public Entity Find(Ecs.FindPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -283,6 +310,7 @@ public Entity Find(Ecs.FindPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T
     public Entity Find(Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -293,6 +321,7 @@ public Entity Find(Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7,
     public Entity Find(Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -303,6 +332,7 @@ public Entity Find(Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T
     public Entity Find(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -313,6 +343,7 @@ public Entity Find(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, b
     public Entity Find(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -323,6 +354,7 @@ public Entity Find(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*
     public Entity Find(delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 }
\ No newline at end of file
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/Query/Query.IIterable/T11.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/Query/Query.IIterable/T11.g.cs
index 1a97489f..5e42e7a1 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/Query/Query.IIterable/T11.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/Query/Query.IIterable/T11.g.cs
@@ -13,6 +13,7 @@ public unsafe partial struct Query<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>
     public void Run(Ecs.RunCallback callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Run(ref this, callback);
     }
 
@@ -23,6 +24,7 @@ public void Run(Ecs.RunCallback callback)
     public void Run(delegate*<Iter, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Run(ref this, callback);
     }
 
@@ -33,6 +35,7 @@ public void Run(delegate*<Iter, void> callback)
     public void Iter(Ecs.IterFieldCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -43,6 +46,7 @@ public void Iter(Ecs.IterFieldCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T
     public void Iter(Ecs.IterSpanCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -53,6 +57,7 @@ public void Iter(Ecs.IterSpanCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T1
     public void Iter(Ecs.IterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -63,6 +68,7 @@ public void Iter(Ecs.IterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9,
     public void Iter(delegate*<Iter, Field<T0>, Field<T1>, Field<T2>, Field<T3>, Field<T4>, Field<T5>, Field<T6>, Field<T7>, Field<T8>, Field<T9>, Field<T10>, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -73,6 +79,7 @@ public void Iter(delegate*<Iter, Field<T0>, Field<T1>, Field<T2>, Field<T3>, Fie
     public void Iter(delegate*<Iter, Span<T0>, Span<T1>, Span<T2>, Span<T3>, Span<T4>, Span<T5>, Span<T6>, Span<T7>, Span<T8>, Span<T9>, Span<T10>, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -83,6 +90,7 @@ public void Iter(delegate*<Iter, Span<T0>, Span<T1>, Span<T2>, Span<T3>, Span<T4
     public void Iter(delegate*<Iter, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -93,6 +101,7 @@ public void Iter(delegate*<Iter, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9
     public void Each(Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -103,6 +112,7 @@ public void Each(Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10
     public void Each(Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -113,6 +123,7 @@ public void Each(Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T
     public void Each(Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -123,6 +134,7 @@ public void Each(Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9,
     public void Each(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -133,6 +145,7 @@ public void Each(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T
     public void Each(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -143,6 +156,7 @@ public void Each(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T
     public void Each(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -153,6 +167,7 @@ public void Each(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, re
     public void Each(Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -163,6 +178,7 @@ public void Each(Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9,
     public void Each(Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -173,6 +189,7 @@ public void Each(Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T
     public void Each(Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -183,6 +200,7 @@ public void Each(Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8,
     public void Each(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -193,6 +211,7 @@ public void Each(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10
     public void Each(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -203,6 +222,7 @@ public void Each(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*,
     public void Each(delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -213,6 +233,7 @@ public void Each(delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8
     public Entity Find(Ecs.FindRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -223,6 +244,7 @@ public Entity Find(Ecs.FindRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T
     public Entity Find(Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -233,6 +255,7 @@ public Entity Find(Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8,
     public Entity Find(Ecs.FindIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -243,6 +266,7 @@ public Entity Find(Ecs.FindIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T
     public Entity Find(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -253,6 +277,7 @@ public Entity Find(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref
     public Entity Find(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -263,6 +288,7 @@ public Entity Find(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref
     public Entity Find(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -273,6 +299,7 @@ public Entity Find(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4,
     public Entity Find(Ecs.FindPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -283,6 +310,7 @@ public Entity Find(Ecs.FindPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T
     public Entity Find(Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -293,6 +321,7 @@ public Entity Find(Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7,
     public Entity Find(Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -303,6 +332,7 @@ public Entity Find(Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T
     public Entity Find(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -313,6 +343,7 @@ public Entity Find(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T
     public Entity Find(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -323,6 +354,7 @@ public Entity Find(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*
     public Entity Find(delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 }
\ No newline at end of file
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/Query/Query.IIterable/T12.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/Query/Query.IIterable/T12.g.cs
index cafc22e5..af7ca815 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/Query/Query.IIterable/T12.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/Query/Query.IIterable/T12.g.cs
@@ -13,6 +13,7 @@ public unsafe partial struct Query<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10,
     public void Run(Ecs.RunCallback callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Run(ref this, callback);
     }
 
@@ -23,6 +24,7 @@ public void Run(Ecs.RunCallback callback)
     public void Run(delegate*<Iter, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Run(ref this, callback);
     }
 
@@ -33,6 +35,7 @@ public void Run(delegate*<Iter, void> callback)
     public void Iter(Ecs.IterFieldCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -43,6 +46,7 @@ public void Iter(Ecs.IterFieldCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T
     public void Iter(Ecs.IterSpanCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -53,6 +57,7 @@ public void Iter(Ecs.IterSpanCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T1
     public void Iter(Ecs.IterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -63,6 +68,7 @@ public void Iter(Ecs.IterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9,
     public void Iter(delegate*<Iter, Field<T0>, Field<T1>, Field<T2>, Field<T3>, Field<T4>, Field<T5>, Field<T6>, Field<T7>, Field<T8>, Field<T9>, Field<T10>, Field<T11>, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -73,6 +79,7 @@ public void Iter(delegate*<Iter, Field<T0>, Field<T1>, Field<T2>, Field<T3>, Fie
     public void Iter(delegate*<Iter, Span<T0>, Span<T1>, Span<T2>, Span<T3>, Span<T4>, Span<T5>, Span<T6>, Span<T7>, Span<T8>, Span<T9>, Span<T10>, Span<T11>, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -83,6 +90,7 @@ public void Iter(delegate*<Iter, Span<T0>, Span<T1>, Span<T2>, Span<T3>, Span<T4
     public void Iter(delegate*<Iter, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -93,6 +101,7 @@ public void Iter(delegate*<Iter, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9
     public void Each(Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -103,6 +112,7 @@ public void Each(Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10
     public void Each(Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -113,6 +123,7 @@ public void Each(Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T
     public void Each(Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -123,6 +134,7 @@ public void Each(Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9,
     public void Each(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -133,6 +145,7 @@ public void Each(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T
     public void Each(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -143,6 +156,7 @@ public void Each(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T
     public void Each(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -153,6 +167,7 @@ public void Each(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, re
     public void Each(Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -163,6 +178,7 @@ public void Each(Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9,
     public void Each(Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -173,6 +189,7 @@ public void Each(Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T
     public void Each(Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -183,6 +200,7 @@ public void Each(Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8,
     public void Each(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -193,6 +211,7 @@ public void Each(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10
     public void Each(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -203,6 +222,7 @@ public void Each(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*,
     public void Each(delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -213,6 +233,7 @@ public void Each(delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8
     public Entity Find(Ecs.FindRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -223,6 +244,7 @@ public Entity Find(Ecs.FindRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T
     public Entity Find(Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -233,6 +255,7 @@ public Entity Find(Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8,
     public Entity Find(Ecs.FindIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -243,6 +266,7 @@ public Entity Find(Ecs.FindIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T
     public Entity Find(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -253,6 +277,7 @@ public Entity Find(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref
     public Entity Find(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -263,6 +288,7 @@ public Entity Find(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref
     public Entity Find(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -273,6 +299,7 @@ public Entity Find(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4,
     public Entity Find(Ecs.FindPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -283,6 +310,7 @@ public Entity Find(Ecs.FindPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T
     public Entity Find(Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -293,6 +321,7 @@ public Entity Find(Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7,
     public Entity Find(Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -303,6 +332,7 @@ public Entity Find(Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T
     public Entity Find(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -313,6 +343,7 @@ public Entity Find(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T
     public Entity Find(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -323,6 +354,7 @@ public Entity Find(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*
     public Entity Find(delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 }
\ No newline at end of file
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/Query/Query.IIterable/T13.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/Query/Query.IIterable/T13.g.cs
index 6e186ea0..3b6bea73 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/Query/Query.IIterable/T13.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/Query/Query.IIterable/T13.g.cs
@@ -13,6 +13,7 @@ public unsafe partial struct Query<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10,
     public void Run(Ecs.RunCallback callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Run(ref this, callback);
     }
 
@@ -23,6 +24,7 @@ public void Run(Ecs.RunCallback callback)
     public void Run(delegate*<Iter, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Run(ref this, callback);
     }
 
@@ -33,6 +35,7 @@ public void Run(delegate*<Iter, void> callback)
     public void Iter(Ecs.IterFieldCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -43,6 +46,7 @@ public void Iter(Ecs.IterFieldCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T
     public void Iter(Ecs.IterSpanCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -53,6 +57,7 @@ public void Iter(Ecs.IterSpanCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T1
     public void Iter(Ecs.IterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -63,6 +68,7 @@ public void Iter(Ecs.IterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9,
     public void Iter(delegate*<Iter, Field<T0>, Field<T1>, Field<T2>, Field<T3>, Field<T4>, Field<T5>, Field<T6>, Field<T7>, Field<T8>, Field<T9>, Field<T10>, Field<T11>, Field<T12>, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -73,6 +79,7 @@ public void Iter(delegate*<Iter, Field<T0>, Field<T1>, Field<T2>, Field<T3>, Fie
     public void Iter(delegate*<Iter, Span<T0>, Span<T1>, Span<T2>, Span<T3>, Span<T4>, Span<T5>, Span<T6>, Span<T7>, Span<T8>, Span<T9>, Span<T10>, Span<T11>, Span<T12>, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -83,6 +90,7 @@ public void Iter(delegate*<Iter, Span<T0>, Span<T1>, Span<T2>, Span<T3>, Span<T4
     public void Iter(delegate*<Iter, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -93,6 +101,7 @@ public void Iter(delegate*<Iter, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9
     public void Each(Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -103,6 +112,7 @@ public void Each(Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10
     public void Each(Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -113,6 +123,7 @@ public void Each(Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T
     public void Each(Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -123,6 +134,7 @@ public void Each(Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9,
     public void Each(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -133,6 +145,7 @@ public void Each(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T
     public void Each(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -143,6 +156,7 @@ public void Each(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T
     public void Each(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -153,6 +167,7 @@ public void Each(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, re
     public void Each(Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -163,6 +178,7 @@ public void Each(Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9,
     public void Each(Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -173,6 +189,7 @@ public void Each(Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T
     public void Each(Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -183,6 +200,7 @@ public void Each(Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8,
     public void Each(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -193,6 +211,7 @@ public void Each(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10
     public void Each(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -203,6 +222,7 @@ public void Each(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*,
     public void Each(delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -213,6 +233,7 @@ public void Each(delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8
     public Entity Find(Ecs.FindRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -223,6 +244,7 @@ public Entity Find(Ecs.FindRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T
     public Entity Find(Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -233,6 +255,7 @@ public Entity Find(Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8,
     public Entity Find(Ecs.FindIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -243,6 +266,7 @@ public Entity Find(Ecs.FindIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T
     public Entity Find(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -253,6 +277,7 @@ public Entity Find(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref
     public Entity Find(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -263,6 +288,7 @@ public Entity Find(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref
     public Entity Find(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -273,6 +299,7 @@ public Entity Find(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4,
     public Entity Find(Ecs.FindPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -283,6 +310,7 @@ public Entity Find(Ecs.FindPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T
     public Entity Find(Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -293,6 +321,7 @@ public Entity Find(Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7,
     public Entity Find(Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -303,6 +332,7 @@ public Entity Find(Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T
     public Entity Find(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -313,6 +343,7 @@ public Entity Find(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T
     public Entity Find(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -323,6 +354,7 @@ public Entity Find(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*
     public Entity Find(delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 }
\ No newline at end of file
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/Query/Query.IIterable/T14.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/Query/Query.IIterable/T14.g.cs
index 982679da..a7bbe9b1 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/Query/Query.IIterable/T14.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/Query/Query.IIterable/T14.g.cs
@@ -13,6 +13,7 @@ public unsafe partial struct Query<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10,
     public void Run(Ecs.RunCallback callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Run(ref this, callback);
     }
 
@@ -23,6 +24,7 @@ public void Run(Ecs.RunCallback callback)
     public void Run(delegate*<Iter, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Run(ref this, callback);
     }
 
@@ -33,6 +35,7 @@ public void Run(delegate*<Iter, void> callback)
     public void Iter(Ecs.IterFieldCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -43,6 +46,7 @@ public void Iter(Ecs.IterFieldCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T
     public void Iter(Ecs.IterSpanCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -53,6 +57,7 @@ public void Iter(Ecs.IterSpanCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T1
     public void Iter(Ecs.IterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -63,6 +68,7 @@ public void Iter(Ecs.IterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9,
     public void Iter(delegate*<Iter, Field<T0>, Field<T1>, Field<T2>, Field<T3>, Field<T4>, Field<T5>, Field<T6>, Field<T7>, Field<T8>, Field<T9>, Field<T10>, Field<T11>, Field<T12>, Field<T13>, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -73,6 +79,7 @@ public void Iter(delegate*<Iter, Field<T0>, Field<T1>, Field<T2>, Field<T3>, Fie
     public void Iter(delegate*<Iter, Span<T0>, Span<T1>, Span<T2>, Span<T3>, Span<T4>, Span<T5>, Span<T6>, Span<T7>, Span<T8>, Span<T9>, Span<T10>, Span<T11>, Span<T12>, Span<T13>, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -83,6 +90,7 @@ public void Iter(delegate*<Iter, Span<T0>, Span<T1>, Span<T2>, Span<T3>, Span<T4
     public void Iter(delegate*<Iter, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -93,6 +101,7 @@ public void Iter(delegate*<Iter, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9
     public void Each(Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -103,6 +112,7 @@ public void Each(Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10
     public void Each(Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -113,6 +123,7 @@ public void Each(Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T
     public void Each(Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -123,6 +134,7 @@ public void Each(Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9,
     public void Each(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -133,6 +145,7 @@ public void Each(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T
     public void Each(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -143,6 +156,7 @@ public void Each(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T
     public void Each(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -153,6 +167,7 @@ public void Each(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, re
     public void Each(Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -163,6 +178,7 @@ public void Each(Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9,
     public void Each(Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -173,6 +189,7 @@ public void Each(Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T
     public void Each(Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -183,6 +200,7 @@ public void Each(Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8,
     public void Each(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -193,6 +211,7 @@ public void Each(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10
     public void Each(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -203,6 +222,7 @@ public void Each(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*,
     public void Each(delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -213,6 +233,7 @@ public void Each(delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8
     public Entity Find(Ecs.FindRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -223,6 +244,7 @@ public Entity Find(Ecs.FindRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T
     public Entity Find(Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -233,6 +255,7 @@ public Entity Find(Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8,
     public Entity Find(Ecs.FindIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -243,6 +266,7 @@ public Entity Find(Ecs.FindIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T
     public Entity Find(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -253,6 +277,7 @@ public Entity Find(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref
     public Entity Find(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -263,6 +288,7 @@ public Entity Find(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref
     public Entity Find(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -273,6 +299,7 @@ public Entity Find(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4,
     public Entity Find(Ecs.FindPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -283,6 +310,7 @@ public Entity Find(Ecs.FindPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T
     public Entity Find(Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -293,6 +321,7 @@ public Entity Find(Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7,
     public Entity Find(Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -303,6 +332,7 @@ public Entity Find(Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T
     public Entity Find(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -313,6 +343,7 @@ public Entity Find(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T
     public Entity Find(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -323,6 +354,7 @@ public Entity Find(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*
     public Entity Find(delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 }
\ No newline at end of file
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/Query/Query.IIterable/T15.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/Query/Query.IIterable/T15.g.cs
index cb6b2a94..7ad907e1 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/Query/Query.IIterable/T15.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/Query/Query.IIterable/T15.g.cs
@@ -13,6 +13,7 @@ public unsafe partial struct Query<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10,
     public void Run(Ecs.RunCallback callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Run(ref this, callback);
     }
 
@@ -23,6 +24,7 @@ public void Run(Ecs.RunCallback callback)
     public void Run(delegate*<Iter, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Run(ref this, callback);
     }
 
@@ -33,6 +35,7 @@ public void Run(delegate*<Iter, void> callback)
     public void Iter(Ecs.IterFieldCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -43,6 +46,7 @@ public void Iter(Ecs.IterFieldCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T
     public void Iter(Ecs.IterSpanCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -53,6 +57,7 @@ public void Iter(Ecs.IterSpanCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T1
     public void Iter(Ecs.IterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -63,6 +68,7 @@ public void Iter(Ecs.IterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9,
     public void Iter(delegate*<Iter, Field<T0>, Field<T1>, Field<T2>, Field<T3>, Field<T4>, Field<T5>, Field<T6>, Field<T7>, Field<T8>, Field<T9>, Field<T10>, Field<T11>, Field<T12>, Field<T13>, Field<T14>, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -73,6 +79,7 @@ public void Iter(delegate*<Iter, Field<T0>, Field<T1>, Field<T2>, Field<T3>, Fie
     public void Iter(delegate*<Iter, Span<T0>, Span<T1>, Span<T2>, Span<T3>, Span<T4>, Span<T5>, Span<T6>, Span<T7>, Span<T8>, Span<T9>, Span<T10>, Span<T11>, Span<T12>, Span<T13>, Span<T14>, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -83,6 +90,7 @@ public void Iter(delegate*<Iter, Span<T0>, Span<T1>, Span<T2>, Span<T3>, Span<T4
     public void Iter(delegate*<Iter, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, T14*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -93,6 +101,7 @@ public void Iter(delegate*<Iter, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9
     public void Each(Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -103,6 +112,7 @@ public void Each(Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10
     public void Each(Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -113,6 +123,7 @@ public void Each(Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T
     public void Each(Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -123,6 +134,7 @@ public void Each(Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9,
     public void Each(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, ref T14, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -133,6 +145,7 @@ public void Each(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T
     public void Each(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, ref T14, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -143,6 +156,7 @@ public void Each(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T
     public void Each(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, ref T14, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -153,6 +167,7 @@ public void Each(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, re
     public void Each(Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -163,6 +178,7 @@ public void Each(Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9,
     public void Each(Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -173,6 +189,7 @@ public void Each(Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T
     public void Each(Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -183,6 +200,7 @@ public void Each(Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8,
     public void Each(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, T14*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -193,6 +211,7 @@ public void Each(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10
     public void Each(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, T14*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -203,6 +222,7 @@ public void Each(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*,
     public void Each(delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, T14*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -213,6 +233,7 @@ public void Each(delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8
     public Entity Find(Ecs.FindRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -223,6 +244,7 @@ public Entity Find(Ecs.FindRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T
     public Entity Find(Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -233,6 +255,7 @@ public Entity Find(Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8,
     public Entity Find(Ecs.FindIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -243,6 +266,7 @@ public Entity Find(Ecs.FindIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T
     public Entity Find(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, ref T14, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -253,6 +277,7 @@ public Entity Find(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref
     public Entity Find(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, ref T14, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -263,6 +288,7 @@ public Entity Find(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref
     public Entity Find(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, ref T14, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -273,6 +299,7 @@ public Entity Find(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4,
     public Entity Find(Ecs.FindPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -283,6 +310,7 @@ public Entity Find(Ecs.FindPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T
     public Entity Find(Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -293,6 +321,7 @@ public Entity Find(Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7,
     public Entity Find(Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -303,6 +332,7 @@ public Entity Find(Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T
     public Entity Find(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, T14*, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -313,6 +343,7 @@ public Entity Find(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T
     public Entity Find(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, T14*, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -323,6 +354,7 @@ public Entity Find(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*
     public Entity Find(delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, T14*, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 }
\ No newline at end of file
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/Query/Query.IIterable/T16.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/Query/Query.IIterable/T16.g.cs
index a547e437..a96d277f 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/Query/Query.IIterable/T16.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/Query/Query.IIterable/T16.g.cs
@@ -13,6 +13,7 @@ public unsafe partial struct Query<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10,
     public void Run(Ecs.RunCallback callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Run(ref this, callback);
     }
 
@@ -23,6 +24,7 @@ public void Run(Ecs.RunCallback callback)
     public void Run(delegate*<Iter, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Run(ref this, callback);
     }
 
@@ -33,6 +35,7 @@ public void Run(delegate*<Iter, void> callback)
     public void Iter(Ecs.IterFieldCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -43,6 +46,7 @@ public void Iter(Ecs.IterFieldCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T
     public void Iter(Ecs.IterSpanCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -53,6 +57,7 @@ public void Iter(Ecs.IterSpanCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T1
     public void Iter(Ecs.IterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -63,6 +68,7 @@ public void Iter(Ecs.IterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9,
     public void Iter(delegate*<Iter, Field<T0>, Field<T1>, Field<T2>, Field<T3>, Field<T4>, Field<T5>, Field<T6>, Field<T7>, Field<T8>, Field<T9>, Field<T10>, Field<T11>, Field<T12>, Field<T13>, Field<T14>, Field<T15>, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -73,6 +79,7 @@ public void Iter(delegate*<Iter, Field<T0>, Field<T1>, Field<T2>, Field<T3>, Fie
     public void Iter(delegate*<Iter, Span<T0>, Span<T1>, Span<T2>, Span<T3>, Span<T4>, Span<T5>, Span<T6>, Span<T7>, Span<T8>, Span<T9>, Span<T10>, Span<T11>, Span<T12>, Span<T13>, Span<T14>, Span<T15>, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -83,6 +90,7 @@ public void Iter(delegate*<Iter, Span<T0>, Span<T1>, Span<T2>, Span<T3>, Span<T4
     public void Iter(delegate*<Iter, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, T14*, T15*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -93,6 +101,7 @@ public void Iter(delegate*<Iter, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9
     public void Each(Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -103,6 +112,7 @@ public void Each(Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10
     public void Each(Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -113,6 +123,7 @@ public void Each(Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T
     public void Each(Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -123,6 +134,7 @@ public void Each(Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9,
     public void Each(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, ref T14, ref T15, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -133,6 +145,7 @@ public void Each(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T
     public void Each(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, ref T14, ref T15, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -143,6 +156,7 @@ public void Each(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T
     public void Each(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, ref T14, ref T15, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -153,6 +167,7 @@ public void Each(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, re
     public void Each(Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -163,6 +178,7 @@ public void Each(Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9,
     public void Each(Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -173,6 +189,7 @@ public void Each(Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T
     public void Each(Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -183,6 +200,7 @@ public void Each(Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8,
     public void Each(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, T14*, T15*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -193,6 +211,7 @@ public void Each(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10
     public void Each(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, T14*, T15*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -203,6 +222,7 @@ public void Each(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*,
     public void Each(delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, T14*, T15*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -213,6 +233,7 @@ public void Each(delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8
     public Entity Find(Ecs.FindRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -223,6 +244,7 @@ public Entity Find(Ecs.FindRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T
     public Entity Find(Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -233,6 +255,7 @@ public Entity Find(Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8,
     public Entity Find(Ecs.FindIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -243,6 +266,7 @@ public Entity Find(Ecs.FindIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T
     public Entity Find(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, ref T14, ref T15, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -253,6 +277,7 @@ public Entity Find(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref
     public Entity Find(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, ref T14, ref T15, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -263,6 +288,7 @@ public Entity Find(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref
     public Entity Find(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, ref T14, ref T15, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -273,6 +299,7 @@ public Entity Find(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4,
     public Entity Find(Ecs.FindPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -283,6 +310,7 @@ public Entity Find(Ecs.FindPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T
     public Entity Find(Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -293,6 +321,7 @@ public Entity Find(Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7,
     public Entity Find(Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -303,6 +332,7 @@ public Entity Find(Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T
     public Entity Find(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, T14*, T15*, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -313,6 +343,7 @@ public Entity Find(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T
     public Entity Find(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, T14*, T15*, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -323,6 +354,7 @@ public Entity Find(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*
     public Entity Find(delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, T14*, T15*, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 }
\ No newline at end of file
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/Query/Query.IIterable/T2.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/Query/Query.IIterable/T2.g.cs
index 8802eb34..98b0b48e 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/Query/Query.IIterable/T2.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/Query/Query.IIterable/T2.g.cs
@@ -13,6 +13,7 @@ public unsafe partial struct Query<T0, T1>
     public void Run(Ecs.RunCallback callback)
     {
         TypeHelper<T0, T1>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Run(ref this, callback);
     }
 
@@ -23,6 +24,7 @@ public void Run(Ecs.RunCallback callback)
     public void Run(delegate*<Iter, void> callback)
     {
         TypeHelper<T0, T1>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Run(ref this, callback);
     }
 
@@ -33,6 +35,7 @@ public void Run(delegate*<Iter, void> callback)
     public void Iter(Ecs.IterFieldCallback<T0, T1> callback)
     {
         TypeHelper<T0, T1>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -43,6 +46,7 @@ public void Iter(Ecs.IterFieldCallback<T0, T1> callback)
     public void Iter(Ecs.IterSpanCallback<T0, T1> callback)
     {
         TypeHelper<T0, T1>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -53,6 +57,7 @@ public void Iter(Ecs.IterSpanCallback<T0, T1> callback)
     public void Iter(Ecs.IterPointerCallback<T0, T1> callback)
     {
         TypeHelper<T0, T1>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -63,6 +68,7 @@ public void Iter(Ecs.IterPointerCallback<T0, T1> callback)
     public void Iter(delegate*<Iter, Field<T0>, Field<T1>, void> callback)
     {
         TypeHelper<T0, T1>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -73,6 +79,7 @@ public void Iter(delegate*<Iter, Field<T0>, Field<T1>, void> callback)
     public void Iter(delegate*<Iter, Span<T0>, Span<T1>, void> callback)
     {
         TypeHelper<T0, T1>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -83,6 +90,7 @@ public void Iter(delegate*<Iter, Span<T0>, Span<T1>, void> callback)
     public void Iter(delegate*<Iter, T0*, T1*, void> callback)
     {
         TypeHelper<T0, T1>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -93,6 +101,7 @@ public void Iter(delegate*<Iter, T0*, T1*, void> callback)
     public void Each(Ecs.EachRefCallback<T0, T1> callback)
     {
         TypeHelper<T0, T1>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -103,6 +112,7 @@ public void Each(Ecs.EachRefCallback<T0, T1> callback)
     public void Each(Ecs.EachEntityRefCallback<T0, T1> callback)
     {
         TypeHelper<T0, T1>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -113,6 +123,7 @@ public void Each(Ecs.EachEntityRefCallback<T0, T1> callback)
     public void Each(Ecs.EachIterRefCallback<T0, T1> callback)
     {
         TypeHelper<T0, T1>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -123,6 +134,7 @@ public void Each(Ecs.EachIterRefCallback<T0, T1> callback)
     public void Each(delegate*<ref T0, ref T1, void> callback)
     {
         TypeHelper<T0, T1>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -133,6 +145,7 @@ public void Each(delegate*<ref T0, ref T1, void> callback)
     public void Each(delegate*<Entity, ref T0, ref T1, void> callback)
     {
         TypeHelper<T0, T1>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -143,6 +156,7 @@ public void Each(delegate*<Entity, ref T0, ref T1, void> callback)
     public void Each(delegate*<Iter, int, ref T0, ref T1, void> callback)
     {
         TypeHelper<T0, T1>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -153,6 +167,7 @@ public void Each(delegate*<Iter, int, ref T0, ref T1, void> callback)
     public void Each(Ecs.EachPointerCallback<T0, T1> callback)
     {
         TypeHelper<T0, T1>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -163,6 +178,7 @@ public void Each(Ecs.EachPointerCallback<T0, T1> callback)
     public void Each(Ecs.EachEntityPointerCallback<T0, T1> callback)
     {
         TypeHelper<T0, T1>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -173,6 +189,7 @@ public void Each(Ecs.EachEntityPointerCallback<T0, T1> callback)
     public void Each(Ecs.EachIterPointerCallback<T0, T1> callback)
     {
         TypeHelper<T0, T1>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -183,6 +200,7 @@ public void Each(Ecs.EachIterPointerCallback<T0, T1> callback)
     public void Each(delegate*<T0*, T1*, void> callback)
     {
         TypeHelper<T0, T1>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -193,6 +211,7 @@ public void Each(delegate*<T0*, T1*, void> callback)
     public void Each(delegate*<Entity, T0*, T1*, void> callback)
     {
         TypeHelper<T0, T1>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -203,6 +222,7 @@ public void Each(delegate*<Entity, T0*, T1*, void> callback)
     public void Each(delegate*<Iter, int, T0*, T1*, void> callback)
     {
         TypeHelper<T0, T1>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -213,6 +233,7 @@ public void Each(delegate*<Iter, int, T0*, T1*, void> callback)
     public Entity Find(Ecs.FindRefCallback<T0, T1> callback)
     {
         TypeHelper<T0, T1>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -223,6 +244,7 @@ public Entity Find(Ecs.FindRefCallback<T0, T1> callback)
     public Entity Find(Ecs.FindEntityRefCallback<T0, T1> callback)
     {
         TypeHelper<T0, T1>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -233,6 +255,7 @@ public Entity Find(Ecs.FindEntityRefCallback<T0, T1> callback)
     public Entity Find(Ecs.FindIterRefCallback<T0, T1> callback)
     {
         TypeHelper<T0, T1>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -243,6 +266,7 @@ public Entity Find(Ecs.FindIterRefCallback<T0, T1> callback)
     public Entity Find(delegate*<ref T0, ref T1, bool> callback)
     {
         TypeHelper<T0, T1>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -253,6 +277,7 @@ public Entity Find(delegate*<ref T0, ref T1, bool> callback)
     public Entity Find(delegate*<Entity, ref T0, ref T1, bool> callback)
     {
         TypeHelper<T0, T1>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -263,6 +288,7 @@ public Entity Find(delegate*<Entity, ref T0, ref T1, bool> callback)
     public Entity Find(delegate*<Iter, int, ref T0, ref T1, bool> callback)
     {
         TypeHelper<T0, T1>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -273,6 +299,7 @@ public Entity Find(delegate*<Iter, int, ref T0, ref T1, bool> callback)
     public Entity Find(Ecs.FindPointerCallback<T0, T1> callback)
     {
         TypeHelper<T0, T1>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -283,6 +310,7 @@ public Entity Find(Ecs.FindPointerCallback<T0, T1> callback)
     public Entity Find(Ecs.FindEntityPointerCallback<T0, T1> callback)
     {
         TypeHelper<T0, T1>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -293,6 +321,7 @@ public Entity Find(Ecs.FindEntityPointerCallback<T0, T1> callback)
     public Entity Find(Ecs.FindIterPointerCallback<T0, T1> callback)
     {
         TypeHelper<T0, T1>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -303,6 +332,7 @@ public Entity Find(Ecs.FindIterPointerCallback<T0, T1> callback)
     public Entity Find(delegate*<T0*, T1*, bool> callback)
     {
         TypeHelper<T0, T1>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -313,6 +343,7 @@ public Entity Find(delegate*<T0*, T1*, bool> callback)
     public Entity Find(delegate*<Entity, T0*, T1*, bool> callback)
     {
         TypeHelper<T0, T1>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -323,6 +354,7 @@ public Entity Find(delegate*<Entity, T0*, T1*, bool> callback)
     public Entity Find(delegate*<Iter, int, T0*, T1*, bool> callback)
     {
         TypeHelper<T0, T1>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 }
\ No newline at end of file
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/Query/Query.IIterable/T3.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/Query/Query.IIterable/T3.g.cs
index 9f2fa957..ae5d6b86 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/Query/Query.IIterable/T3.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/Query/Query.IIterable/T3.g.cs
@@ -13,6 +13,7 @@ public unsafe partial struct Query<T0, T1, T2>
     public void Run(Ecs.RunCallback callback)
     {
         TypeHelper<T0, T1, T2>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Run(ref this, callback);
     }
 
@@ -23,6 +24,7 @@ public void Run(Ecs.RunCallback callback)
     public void Run(delegate*<Iter, void> callback)
     {
         TypeHelper<T0, T1, T2>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Run(ref this, callback);
     }
 
@@ -33,6 +35,7 @@ public void Run(delegate*<Iter, void> callback)
     public void Iter(Ecs.IterFieldCallback<T0, T1, T2> callback)
     {
         TypeHelper<T0, T1, T2>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -43,6 +46,7 @@ public void Iter(Ecs.IterFieldCallback<T0, T1, T2> callback)
     public void Iter(Ecs.IterSpanCallback<T0, T1, T2> callback)
     {
         TypeHelper<T0, T1, T2>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -53,6 +57,7 @@ public void Iter(Ecs.IterSpanCallback<T0, T1, T2> callback)
     public void Iter(Ecs.IterPointerCallback<T0, T1, T2> callback)
     {
         TypeHelper<T0, T1, T2>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -63,6 +68,7 @@ public void Iter(Ecs.IterPointerCallback<T0, T1, T2> callback)
     public void Iter(delegate*<Iter, Field<T0>, Field<T1>, Field<T2>, void> callback)
     {
         TypeHelper<T0, T1, T2>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -73,6 +79,7 @@ public void Iter(delegate*<Iter, Field<T0>, Field<T1>, Field<T2>, void> callback
     public void Iter(delegate*<Iter, Span<T0>, Span<T1>, Span<T2>, void> callback)
     {
         TypeHelper<T0, T1, T2>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -83,6 +90,7 @@ public void Iter(delegate*<Iter, Span<T0>, Span<T1>, Span<T2>, void> callback)
     public void Iter(delegate*<Iter, T0*, T1*, T2*, void> callback)
     {
         TypeHelper<T0, T1, T2>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -93,6 +101,7 @@ public void Iter(delegate*<Iter, T0*, T1*, T2*, void> callback)
     public void Each(Ecs.EachRefCallback<T0, T1, T2> callback)
     {
         TypeHelper<T0, T1, T2>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -103,6 +112,7 @@ public void Each(Ecs.EachRefCallback<T0, T1, T2> callback)
     public void Each(Ecs.EachEntityRefCallback<T0, T1, T2> callback)
     {
         TypeHelper<T0, T1, T2>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -113,6 +123,7 @@ public void Each(Ecs.EachEntityRefCallback<T0, T1, T2> callback)
     public void Each(Ecs.EachIterRefCallback<T0, T1, T2> callback)
     {
         TypeHelper<T0, T1, T2>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -123,6 +134,7 @@ public void Each(Ecs.EachIterRefCallback<T0, T1, T2> callback)
     public void Each(delegate*<ref T0, ref T1, ref T2, void> callback)
     {
         TypeHelper<T0, T1, T2>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -133,6 +145,7 @@ public void Each(delegate*<ref T0, ref T1, ref T2, void> callback)
     public void Each(delegate*<Entity, ref T0, ref T1, ref T2, void> callback)
     {
         TypeHelper<T0, T1, T2>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -143,6 +156,7 @@ public void Each(delegate*<Entity, ref T0, ref T1, ref T2, void> callback)
     public void Each(delegate*<Iter, int, ref T0, ref T1, ref T2, void> callback)
     {
         TypeHelper<T0, T1, T2>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -153,6 +167,7 @@ public void Each(delegate*<Iter, int, ref T0, ref T1, ref T2, void> callback)
     public void Each(Ecs.EachPointerCallback<T0, T1, T2> callback)
     {
         TypeHelper<T0, T1, T2>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -163,6 +178,7 @@ public void Each(Ecs.EachPointerCallback<T0, T1, T2> callback)
     public void Each(Ecs.EachEntityPointerCallback<T0, T1, T2> callback)
     {
         TypeHelper<T0, T1, T2>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -173,6 +189,7 @@ public void Each(Ecs.EachEntityPointerCallback<T0, T1, T2> callback)
     public void Each(Ecs.EachIterPointerCallback<T0, T1, T2> callback)
     {
         TypeHelper<T0, T1, T2>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -183,6 +200,7 @@ public void Each(Ecs.EachIterPointerCallback<T0, T1, T2> callback)
     public void Each(delegate*<T0*, T1*, T2*, void> callback)
     {
         TypeHelper<T0, T1, T2>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -193,6 +211,7 @@ public void Each(delegate*<T0*, T1*, T2*, void> callback)
     public void Each(delegate*<Entity, T0*, T1*, T2*, void> callback)
     {
         TypeHelper<T0, T1, T2>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -203,6 +222,7 @@ public void Each(delegate*<Entity, T0*, T1*, T2*, void> callback)
     public void Each(delegate*<Iter, int, T0*, T1*, T2*, void> callback)
     {
         TypeHelper<T0, T1, T2>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -213,6 +233,7 @@ public void Each(delegate*<Iter, int, T0*, T1*, T2*, void> callback)
     public Entity Find(Ecs.FindRefCallback<T0, T1, T2> callback)
     {
         TypeHelper<T0, T1, T2>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -223,6 +244,7 @@ public Entity Find(Ecs.FindRefCallback<T0, T1, T2> callback)
     public Entity Find(Ecs.FindEntityRefCallback<T0, T1, T2> callback)
     {
         TypeHelper<T0, T1, T2>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -233,6 +255,7 @@ public Entity Find(Ecs.FindEntityRefCallback<T0, T1, T2> callback)
     public Entity Find(Ecs.FindIterRefCallback<T0, T1, T2> callback)
     {
         TypeHelper<T0, T1, T2>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -243,6 +266,7 @@ public Entity Find(Ecs.FindIterRefCallback<T0, T1, T2> callback)
     public Entity Find(delegate*<ref T0, ref T1, ref T2, bool> callback)
     {
         TypeHelper<T0, T1, T2>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -253,6 +277,7 @@ public Entity Find(delegate*<ref T0, ref T1, ref T2, bool> callback)
     public Entity Find(delegate*<Entity, ref T0, ref T1, ref T2, bool> callback)
     {
         TypeHelper<T0, T1, T2>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -263,6 +288,7 @@ public Entity Find(delegate*<Entity, ref T0, ref T1, ref T2, bool> callback)
     public Entity Find(delegate*<Iter, int, ref T0, ref T1, ref T2, bool> callback)
     {
         TypeHelper<T0, T1, T2>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -273,6 +299,7 @@ public Entity Find(delegate*<Iter, int, ref T0, ref T1, ref T2, bool> callback)
     public Entity Find(Ecs.FindPointerCallback<T0, T1, T2> callback)
     {
         TypeHelper<T0, T1, T2>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -283,6 +310,7 @@ public Entity Find(Ecs.FindPointerCallback<T0, T1, T2> callback)
     public Entity Find(Ecs.FindEntityPointerCallback<T0, T1, T2> callback)
     {
         TypeHelper<T0, T1, T2>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -293,6 +321,7 @@ public Entity Find(Ecs.FindEntityPointerCallback<T0, T1, T2> callback)
     public Entity Find(Ecs.FindIterPointerCallback<T0, T1, T2> callback)
     {
         TypeHelper<T0, T1, T2>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -303,6 +332,7 @@ public Entity Find(Ecs.FindIterPointerCallback<T0, T1, T2> callback)
     public Entity Find(delegate*<T0*, T1*, T2*, bool> callback)
     {
         TypeHelper<T0, T1, T2>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -313,6 +343,7 @@ public Entity Find(delegate*<T0*, T1*, T2*, bool> callback)
     public Entity Find(delegate*<Entity, T0*, T1*, T2*, bool> callback)
     {
         TypeHelper<T0, T1, T2>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -323,6 +354,7 @@ public Entity Find(delegate*<Entity, T0*, T1*, T2*, bool> callback)
     public Entity Find(delegate*<Iter, int, T0*, T1*, T2*, bool> callback)
     {
         TypeHelper<T0, T1, T2>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 }
\ No newline at end of file
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/Query/Query.IIterable/T4.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/Query/Query.IIterable/T4.g.cs
index 6fb0c86c..43bca8cb 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/Query/Query.IIterable/T4.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/Query/Query.IIterable/T4.g.cs
@@ -13,6 +13,7 @@ public unsafe partial struct Query<T0, T1, T2, T3>
     public void Run(Ecs.RunCallback callback)
     {
         TypeHelper<T0, T1, T2, T3>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Run(ref this, callback);
     }
 
@@ -23,6 +24,7 @@ public void Run(Ecs.RunCallback callback)
     public void Run(delegate*<Iter, void> callback)
     {
         TypeHelper<T0, T1, T2, T3>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Run(ref this, callback);
     }
 
@@ -33,6 +35,7 @@ public void Run(delegate*<Iter, void> callback)
     public void Iter(Ecs.IterFieldCallback<T0, T1, T2, T3> callback)
     {
         TypeHelper<T0, T1, T2, T3>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -43,6 +46,7 @@ public void Iter(Ecs.IterFieldCallback<T0, T1, T2, T3> callback)
     public void Iter(Ecs.IterSpanCallback<T0, T1, T2, T3> callback)
     {
         TypeHelper<T0, T1, T2, T3>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -53,6 +57,7 @@ public void Iter(Ecs.IterSpanCallback<T0, T1, T2, T3> callback)
     public void Iter(Ecs.IterPointerCallback<T0, T1, T2, T3> callback)
     {
         TypeHelper<T0, T1, T2, T3>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -63,6 +68,7 @@ public void Iter(Ecs.IterPointerCallback<T0, T1, T2, T3> callback)
     public void Iter(delegate*<Iter, Field<T0>, Field<T1>, Field<T2>, Field<T3>, void> callback)
     {
         TypeHelper<T0, T1, T2, T3>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -73,6 +79,7 @@ public void Iter(delegate*<Iter, Field<T0>, Field<T1>, Field<T2>, Field<T3>, voi
     public void Iter(delegate*<Iter, Span<T0>, Span<T1>, Span<T2>, Span<T3>, void> callback)
     {
         TypeHelper<T0, T1, T2, T3>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -83,6 +90,7 @@ public void Iter(delegate*<Iter, Span<T0>, Span<T1>, Span<T2>, Span<T3>, void> c
     public void Iter(delegate*<Iter, T0*, T1*, T2*, T3*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -93,6 +101,7 @@ public void Iter(delegate*<Iter, T0*, T1*, T2*, T3*, void> callback)
     public void Each(Ecs.EachRefCallback<T0, T1, T2, T3> callback)
     {
         TypeHelper<T0, T1, T2, T3>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -103,6 +112,7 @@ public void Each(Ecs.EachRefCallback<T0, T1, T2, T3> callback)
     public void Each(Ecs.EachEntityRefCallback<T0, T1, T2, T3> callback)
     {
         TypeHelper<T0, T1, T2, T3>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -113,6 +123,7 @@ public void Each(Ecs.EachEntityRefCallback<T0, T1, T2, T3> callback)
     public void Each(Ecs.EachIterRefCallback<T0, T1, T2, T3> callback)
     {
         TypeHelper<T0, T1, T2, T3>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -123,6 +134,7 @@ public void Each(Ecs.EachIterRefCallback<T0, T1, T2, T3> callback)
     public void Each(delegate*<ref T0, ref T1, ref T2, ref T3, void> callback)
     {
         TypeHelper<T0, T1, T2, T3>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -133,6 +145,7 @@ public void Each(delegate*<ref T0, ref T1, ref T2, ref T3, void> callback)
     public void Each(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, void> callback)
     {
         TypeHelper<T0, T1, T2, T3>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -143,6 +156,7 @@ public void Each(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, void> callbac
     public void Each(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, void> callback)
     {
         TypeHelper<T0, T1, T2, T3>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -153,6 +167,7 @@ public void Each(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, void> call
     public void Each(Ecs.EachPointerCallback<T0, T1, T2, T3> callback)
     {
         TypeHelper<T0, T1, T2, T3>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -163,6 +178,7 @@ public void Each(Ecs.EachPointerCallback<T0, T1, T2, T3> callback)
     public void Each(Ecs.EachEntityPointerCallback<T0, T1, T2, T3> callback)
     {
         TypeHelper<T0, T1, T2, T3>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -173,6 +189,7 @@ public void Each(Ecs.EachEntityPointerCallback<T0, T1, T2, T3> callback)
     public void Each(Ecs.EachIterPointerCallback<T0, T1, T2, T3> callback)
     {
         TypeHelper<T0, T1, T2, T3>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -183,6 +200,7 @@ public void Each(Ecs.EachIterPointerCallback<T0, T1, T2, T3> callback)
     public void Each(delegate*<T0*, T1*, T2*, T3*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -193,6 +211,7 @@ public void Each(delegate*<T0*, T1*, T2*, T3*, void> callback)
     public void Each(delegate*<Entity, T0*, T1*, T2*, T3*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -203,6 +222,7 @@ public void Each(delegate*<Entity, T0*, T1*, T2*, T3*, void> callback)
     public void Each(delegate*<Iter, int, T0*, T1*, T2*, T3*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -213,6 +233,7 @@ public void Each(delegate*<Iter, int, T0*, T1*, T2*, T3*, void> callback)
     public Entity Find(Ecs.FindRefCallback<T0, T1, T2, T3> callback)
     {
         TypeHelper<T0, T1, T2, T3>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -223,6 +244,7 @@ public Entity Find(Ecs.FindRefCallback<T0, T1, T2, T3> callback)
     public Entity Find(Ecs.FindEntityRefCallback<T0, T1, T2, T3> callback)
     {
         TypeHelper<T0, T1, T2, T3>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -233,6 +255,7 @@ public Entity Find(Ecs.FindEntityRefCallback<T0, T1, T2, T3> callback)
     public Entity Find(Ecs.FindIterRefCallback<T0, T1, T2, T3> callback)
     {
         TypeHelper<T0, T1, T2, T3>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -243,6 +266,7 @@ public Entity Find(Ecs.FindIterRefCallback<T0, T1, T2, T3> callback)
     public Entity Find(delegate*<ref T0, ref T1, ref T2, ref T3, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -253,6 +277,7 @@ public Entity Find(delegate*<ref T0, ref T1, ref T2, ref T3, bool> callback)
     public Entity Find(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -263,6 +288,7 @@ public Entity Find(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, bool> callb
     public Entity Find(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -273,6 +299,7 @@ public Entity Find(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, bool> ca
     public Entity Find(Ecs.FindPointerCallback<T0, T1, T2, T3> callback)
     {
         TypeHelper<T0, T1, T2, T3>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -283,6 +310,7 @@ public Entity Find(Ecs.FindPointerCallback<T0, T1, T2, T3> callback)
     public Entity Find(Ecs.FindEntityPointerCallback<T0, T1, T2, T3> callback)
     {
         TypeHelper<T0, T1, T2, T3>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -293,6 +321,7 @@ public Entity Find(Ecs.FindEntityPointerCallback<T0, T1, T2, T3> callback)
     public Entity Find(Ecs.FindIterPointerCallback<T0, T1, T2, T3> callback)
     {
         TypeHelper<T0, T1, T2, T3>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -303,6 +332,7 @@ public Entity Find(Ecs.FindIterPointerCallback<T0, T1, T2, T3> callback)
     public Entity Find(delegate*<T0*, T1*, T2*, T3*, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -313,6 +343,7 @@ public Entity Find(delegate*<T0*, T1*, T2*, T3*, bool> callback)
     public Entity Find(delegate*<Entity, T0*, T1*, T2*, T3*, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -323,6 +354,7 @@ public Entity Find(delegate*<Entity, T0*, T1*, T2*, T3*, bool> callback)
     public Entity Find(delegate*<Iter, int, T0*, T1*, T2*, T3*, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 }
\ No newline at end of file
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/Query/Query.IIterable/T5.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/Query/Query.IIterable/T5.g.cs
index fc4dbae4..bb9f260c 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/Query/Query.IIterable/T5.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/Query/Query.IIterable/T5.g.cs
@@ -13,6 +13,7 @@ public unsafe partial struct Query<T0, T1, T2, T3, T4>
     public void Run(Ecs.RunCallback callback)
     {
         TypeHelper<T0, T1, T2, T3, T4>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Run(ref this, callback);
     }
 
@@ -23,6 +24,7 @@ public void Run(Ecs.RunCallback callback)
     public void Run(delegate*<Iter, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Run(ref this, callback);
     }
 
@@ -33,6 +35,7 @@ public void Run(delegate*<Iter, void> callback)
     public void Iter(Ecs.IterFieldCallback<T0, T1, T2, T3, T4> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -43,6 +46,7 @@ public void Iter(Ecs.IterFieldCallback<T0, T1, T2, T3, T4> callback)
     public void Iter(Ecs.IterSpanCallback<T0, T1, T2, T3, T4> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -53,6 +57,7 @@ public void Iter(Ecs.IterSpanCallback<T0, T1, T2, T3, T4> callback)
     public void Iter(Ecs.IterPointerCallback<T0, T1, T2, T3, T4> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -63,6 +68,7 @@ public void Iter(Ecs.IterPointerCallback<T0, T1, T2, T3, T4> callback)
     public void Iter(delegate*<Iter, Field<T0>, Field<T1>, Field<T2>, Field<T3>, Field<T4>, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -73,6 +79,7 @@ public void Iter(delegate*<Iter, Field<T0>, Field<T1>, Field<T2>, Field<T3>, Fie
     public void Iter(delegate*<Iter, Span<T0>, Span<T1>, Span<T2>, Span<T3>, Span<T4>, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -83,6 +90,7 @@ public void Iter(delegate*<Iter, Span<T0>, Span<T1>, Span<T2>, Span<T3>, Span<T4
     public void Iter(delegate*<Iter, T0*, T1*, T2*, T3*, T4*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -93,6 +101,7 @@ public void Iter(delegate*<Iter, T0*, T1*, T2*, T3*, T4*, void> callback)
     public void Each(Ecs.EachRefCallback<T0, T1, T2, T3, T4> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -103,6 +112,7 @@ public void Each(Ecs.EachRefCallback<T0, T1, T2, T3, T4> callback)
     public void Each(Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -113,6 +123,7 @@ public void Each(Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4> callback)
     public void Each(Ecs.EachIterRefCallback<T0, T1, T2, T3, T4> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -123,6 +134,7 @@ public void Each(Ecs.EachIterRefCallback<T0, T1, T2, T3, T4> callback)
     public void Each(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -133,6 +145,7 @@ public void Each(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, void> callbac
     public void Each(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -143,6 +156,7 @@ public void Each(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, void>
     public void Each(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -153,6 +167,7 @@ public void Each(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, vo
     public void Each(Ecs.EachPointerCallback<T0, T1, T2, T3, T4> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -163,6 +178,7 @@ public void Each(Ecs.EachPointerCallback<T0, T1, T2, T3, T4> callback)
     public void Each(Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -173,6 +189,7 @@ public void Each(Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4> callback)
     public void Each(Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -183,6 +200,7 @@ public void Each(Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4> callback)
     public void Each(delegate*<T0*, T1*, T2*, T3*, T4*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -193,6 +211,7 @@ public void Each(delegate*<T0*, T1*, T2*, T3*, T4*, void> callback)
     public void Each(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -203,6 +222,7 @@ public void Each(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, void> callback)
     public void Each(delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -213,6 +233,7 @@ public void Each(delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, void> callback)
     public Entity Find(Ecs.FindRefCallback<T0, T1, T2, T3, T4> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -223,6 +244,7 @@ public Entity Find(Ecs.FindRefCallback<T0, T1, T2, T3, T4> callback)
     public Entity Find(Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -233,6 +255,7 @@ public Entity Find(Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4> callback)
     public Entity Find(Ecs.FindIterRefCallback<T0, T1, T2, T3, T4> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -243,6 +266,7 @@ public Entity Find(Ecs.FindIterRefCallback<T0, T1, T2, T3, T4> callback)
     public Entity Find(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -253,6 +277,7 @@ public Entity Find(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, bool> callb
     public Entity Find(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -263,6 +288,7 @@ public Entity Find(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, boo
     public Entity Find(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -273,6 +299,7 @@ public Entity Find(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4,
     public Entity Find(Ecs.FindPointerCallback<T0, T1, T2, T3, T4> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -283,6 +310,7 @@ public Entity Find(Ecs.FindPointerCallback<T0, T1, T2, T3, T4> callback)
     public Entity Find(Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -293,6 +321,7 @@ public Entity Find(Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4> callback)
     public Entity Find(Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -303,6 +332,7 @@ public Entity Find(Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4> callback)
     public Entity Find(delegate*<T0*, T1*, T2*, T3*, T4*, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -313,6 +343,7 @@ public Entity Find(delegate*<T0*, T1*, T2*, T3*, T4*, bool> callback)
     public Entity Find(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -323,6 +354,7 @@ public Entity Find(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, bool> callback)
     public Entity Find(delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 }
\ No newline at end of file
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/Query/Query.IIterable/T6.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/Query/Query.IIterable/T6.g.cs
index a791af85..81033690 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/Query/Query.IIterable/T6.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/Query/Query.IIterable/T6.g.cs
@@ -13,6 +13,7 @@ public unsafe partial struct Query<T0, T1, T2, T3, T4, T5>
     public void Run(Ecs.RunCallback callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Run(ref this, callback);
     }
 
@@ -23,6 +24,7 @@ public void Run(Ecs.RunCallback callback)
     public void Run(delegate*<Iter, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Run(ref this, callback);
     }
 
@@ -33,6 +35,7 @@ public void Run(delegate*<Iter, void> callback)
     public void Iter(Ecs.IterFieldCallback<T0, T1, T2, T3, T4, T5> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -43,6 +46,7 @@ public void Iter(Ecs.IterFieldCallback<T0, T1, T2, T3, T4, T5> callback)
     public void Iter(Ecs.IterSpanCallback<T0, T1, T2, T3, T4, T5> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -53,6 +57,7 @@ public void Iter(Ecs.IterSpanCallback<T0, T1, T2, T3, T4, T5> callback)
     public void Iter(Ecs.IterPointerCallback<T0, T1, T2, T3, T4, T5> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -63,6 +68,7 @@ public void Iter(Ecs.IterPointerCallback<T0, T1, T2, T3, T4, T5> callback)
     public void Iter(delegate*<Iter, Field<T0>, Field<T1>, Field<T2>, Field<T3>, Field<T4>, Field<T5>, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -73,6 +79,7 @@ public void Iter(delegate*<Iter, Field<T0>, Field<T1>, Field<T2>, Field<T3>, Fie
     public void Iter(delegate*<Iter, Span<T0>, Span<T1>, Span<T2>, Span<T3>, Span<T4>, Span<T5>, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -83,6 +90,7 @@ public void Iter(delegate*<Iter, Span<T0>, Span<T1>, Span<T2>, Span<T3>, Span<T4
     public void Iter(delegate*<Iter, T0*, T1*, T2*, T3*, T4*, T5*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -93,6 +101,7 @@ public void Iter(delegate*<Iter, T0*, T1*, T2*, T3*, T4*, T5*, void> callback)
     public void Each(Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -103,6 +112,7 @@ public void Each(Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5> callback)
     public void Each(Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -113,6 +123,7 @@ public void Each(Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5> callback)
     public void Each(Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -123,6 +134,7 @@ public void Each(Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5> callback)
     public void Each(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -133,6 +145,7 @@ public void Each(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, void>
     public void Each(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -143,6 +156,7 @@ public void Each(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T
     public void Each(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -153,6 +167,7 @@ public void Each(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, re
     public void Each(Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -163,6 +178,7 @@ public void Each(Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5> callback)
     public void Each(Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -173,6 +189,7 @@ public void Each(Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5> callback)
     public void Each(Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -183,6 +200,7 @@ public void Each(Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5> callback)
     public void Each(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -193,6 +211,7 @@ public void Each(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, void> callback)
     public void Each(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -203,6 +222,7 @@ public void Each(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, void> callback)
     public void Each(delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -213,6 +233,7 @@ public void Each(delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, void> callba
     public Entity Find(Ecs.FindRefCallback<T0, T1, T2, T3, T4, T5> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -223,6 +244,7 @@ public Entity Find(Ecs.FindRefCallback<T0, T1, T2, T3, T4, T5> callback)
     public Entity Find(Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4, T5> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -233,6 +255,7 @@ public Entity Find(Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4, T5> callback)
     public Entity Find(Ecs.FindIterRefCallback<T0, T1, T2, T3, T4, T5> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -243,6 +266,7 @@ public Entity Find(Ecs.FindIterRefCallback<T0, T1, T2, T3, T4, T5> callback)
     public Entity Find(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -253,6 +277,7 @@ public Entity Find(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, boo
     public Entity Find(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -263,6 +288,7 @@ public Entity Find(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref
     public Entity Find(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -273,6 +299,7 @@ public Entity Find(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4,
     public Entity Find(Ecs.FindPointerCallback<T0, T1, T2, T3, T4, T5> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -283,6 +310,7 @@ public Entity Find(Ecs.FindPointerCallback<T0, T1, T2, T3, T4, T5> callback)
     public Entity Find(Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4, T5> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -293,6 +321,7 @@ public Entity Find(Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4, T5> callbac
     public Entity Find(Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4, T5> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -303,6 +332,7 @@ public Entity Find(Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4, T5> callback)
     public Entity Find(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -313,6 +343,7 @@ public Entity Find(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, bool> callback)
     public Entity Find(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -323,6 +354,7 @@ public Entity Find(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, bool> callbac
     public Entity Find(delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 }
\ No newline at end of file
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/Query/Query.IIterable/T7.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/Query/Query.IIterable/T7.g.cs
index 360b56d0..4f4d1b98 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/Query/Query.IIterable/T7.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/Query/Query.IIterable/T7.g.cs
@@ -13,6 +13,7 @@ public unsafe partial struct Query<T0, T1, T2, T3, T4, T5, T6>
     public void Run(Ecs.RunCallback callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Run(ref this, callback);
     }
 
@@ -23,6 +24,7 @@ public void Run(Ecs.RunCallback callback)
     public void Run(delegate*<Iter, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Run(ref this, callback);
     }
 
@@ -33,6 +35,7 @@ public void Run(delegate*<Iter, void> callback)
     public void Iter(Ecs.IterFieldCallback<T0, T1, T2, T3, T4, T5, T6> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -43,6 +46,7 @@ public void Iter(Ecs.IterFieldCallback<T0, T1, T2, T3, T4, T5, T6> callback)
     public void Iter(Ecs.IterSpanCallback<T0, T1, T2, T3, T4, T5, T6> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -53,6 +57,7 @@ public void Iter(Ecs.IterSpanCallback<T0, T1, T2, T3, T4, T5, T6> callback)
     public void Iter(Ecs.IterPointerCallback<T0, T1, T2, T3, T4, T5, T6> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -63,6 +68,7 @@ public void Iter(Ecs.IterPointerCallback<T0, T1, T2, T3, T4, T5, T6> callback)
     public void Iter(delegate*<Iter, Field<T0>, Field<T1>, Field<T2>, Field<T3>, Field<T4>, Field<T5>, Field<T6>, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -73,6 +79,7 @@ public void Iter(delegate*<Iter, Field<T0>, Field<T1>, Field<T2>, Field<T3>, Fie
     public void Iter(delegate*<Iter, Span<T0>, Span<T1>, Span<T2>, Span<T3>, Span<T4>, Span<T5>, Span<T6>, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -83,6 +90,7 @@ public void Iter(delegate*<Iter, Span<T0>, Span<T1>, Span<T2>, Span<T3>, Span<T4
     public void Iter(delegate*<Iter, T0*, T1*, T2*, T3*, T4*, T5*, T6*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -93,6 +101,7 @@ public void Iter(delegate*<Iter, T0*, T1*, T2*, T3*, T4*, T5*, T6*, void> callba
     public void Each(Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5, T6> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -103,6 +112,7 @@ public void Each(Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5, T6> callback)
     public void Each(Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5, T6> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -113,6 +123,7 @@ public void Each(Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5, T6> callback)
     public void Each(Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5, T6> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -123,6 +134,7 @@ public void Each(Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5, T6> callback)
     public void Each(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -133,6 +145,7 @@ public void Each(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T
     public void Each(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -143,6 +156,7 @@ public void Each(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T
     public void Each(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -153,6 +167,7 @@ public void Each(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, re
     public void Each(Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5, T6> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -163,6 +178,7 @@ public void Each(Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5, T6> callback)
     public void Each(Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -173,6 +189,7 @@ public void Each(Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6> callb
     public void Each(Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5, T6> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -183,6 +200,7 @@ public void Each(Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5, T6> callbac
     public void Each(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -193,6 +211,7 @@ public void Each(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, void> callback)
     public void Each(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -203,6 +222,7 @@ public void Each(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, void> call
     public void Each(delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -213,6 +233,7 @@ public void Each(delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, void> c
     public Entity Find(Ecs.FindRefCallback<T0, T1, T2, T3, T4, T5, T6> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -223,6 +244,7 @@ public Entity Find(Ecs.FindRefCallback<T0, T1, T2, T3, T4, T5, T6> callback)
     public Entity Find(Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4, T5, T6> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -233,6 +255,7 @@ public Entity Find(Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4, T5, T6> callbac
     public Entity Find(Ecs.FindIterRefCallback<T0, T1, T2, T3, T4, T5, T6> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -243,6 +266,7 @@ public Entity Find(Ecs.FindIterRefCallback<T0, T1, T2, T3, T4, T5, T6> callback)
     public Entity Find(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -253,6 +277,7 @@ public Entity Find(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref
     public Entity Find(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -263,6 +288,7 @@ public Entity Find(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref
     public Entity Find(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -273,6 +299,7 @@ public Entity Find(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4,
     public Entity Find(Ecs.FindPointerCallback<T0, T1, T2, T3, T4, T5, T6> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -283,6 +310,7 @@ public Entity Find(Ecs.FindPointerCallback<T0, T1, T2, T3, T4, T5, T6> callback)
     public Entity Find(Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -293,6 +321,7 @@ public Entity Find(Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6> cal
     public Entity Find(Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4, T5, T6> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -303,6 +332,7 @@ public Entity Find(Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4, T5, T6> callb
     public Entity Find(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -313,6 +343,7 @@ public Entity Find(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, bool> callback)
     public Entity Find(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -323,6 +354,7 @@ public Entity Find(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, bool> ca
     public Entity Find(delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 }
\ No newline at end of file
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/Query/Query.IIterable/T8.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/Query/Query.IIterable/T8.g.cs
index 280faf0f..b5905a98 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/Query/Query.IIterable/T8.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/Query/Query.IIterable/T8.g.cs
@@ -13,6 +13,7 @@ public unsafe partial struct Query<T0, T1, T2, T3, T4, T5, T6, T7>
     public void Run(Ecs.RunCallback callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Run(ref this, callback);
     }
 
@@ -23,6 +24,7 @@ public void Run(Ecs.RunCallback callback)
     public void Run(delegate*<Iter, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Run(ref this, callback);
     }
 
@@ -33,6 +35,7 @@ public void Run(delegate*<Iter, void> callback)
     public void Iter(Ecs.IterFieldCallback<T0, T1, T2, T3, T4, T5, T6, T7> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -43,6 +46,7 @@ public void Iter(Ecs.IterFieldCallback<T0, T1, T2, T3, T4, T5, T6, T7> callback)
     public void Iter(Ecs.IterSpanCallback<T0, T1, T2, T3, T4, T5, T6, T7> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -53,6 +57,7 @@ public void Iter(Ecs.IterSpanCallback<T0, T1, T2, T3, T4, T5, T6, T7> callback)
     public void Iter(Ecs.IterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -63,6 +68,7 @@ public void Iter(Ecs.IterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7> callbac
     public void Iter(delegate*<Iter, Field<T0>, Field<T1>, Field<T2>, Field<T3>, Field<T4>, Field<T5>, Field<T6>, Field<T7>, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -73,6 +79,7 @@ public void Iter(delegate*<Iter, Field<T0>, Field<T1>, Field<T2>, Field<T3>, Fie
     public void Iter(delegate*<Iter, Span<T0>, Span<T1>, Span<T2>, Span<T3>, Span<T4>, Span<T5>, Span<T6>, Span<T7>, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -83,6 +90,7 @@ public void Iter(delegate*<Iter, Span<T0>, Span<T1>, Span<T2>, Span<T3>, Span<T4
     public void Iter(delegate*<Iter, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -93,6 +101,7 @@ public void Iter(delegate*<Iter, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, void> c
     public void Each(Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5, T6, T7> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -103,6 +112,7 @@ public void Each(Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5, T6, T7> callback)
     public void Each(Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -113,6 +123,7 @@ public void Each(Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7> callb
     public void Each(Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -123,6 +134,7 @@ public void Each(Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7> callbac
     public void Each(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -133,6 +145,7 @@ public void Each(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T
     public void Each(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -143,6 +156,7 @@ public void Each(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T
     public void Each(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -153,6 +167,7 @@ public void Each(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, re
     public void Each(Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -163,6 +178,7 @@ public void Each(Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7> callbac
     public void Each(Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -173,6 +189,7 @@ public void Each(Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7> c
     public void Each(Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -183,6 +200,7 @@ public void Each(Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7> cal
     public void Each(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -193,6 +211,7 @@ public void Each(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, void> callbac
     public void Each(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -203,6 +222,7 @@ public void Each(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, void>
     public void Each(delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -213,6 +233,7 @@ public void Each(delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, vo
     public Entity Find(Ecs.FindRefCallback<T0, T1, T2, T3, T4, T5, T6, T7> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -223,6 +244,7 @@ public Entity Find(Ecs.FindRefCallback<T0, T1, T2, T3, T4, T5, T6, T7> callback)
     public Entity Find(Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -233,6 +255,7 @@ public Entity Find(Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7> cal
     public Entity Find(Ecs.FindIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -243,6 +266,7 @@ public Entity Find(Ecs.FindIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7> callb
     public Entity Find(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -253,6 +277,7 @@ public Entity Find(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref
     public Entity Find(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -263,6 +288,7 @@ public Entity Find(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref
     public Entity Find(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -273,6 +299,7 @@ public Entity Find(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4,
     public Entity Find(Ecs.FindPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -283,6 +310,7 @@ public Entity Find(Ecs.FindPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7> callb
     public Entity Find(Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -293,6 +321,7 @@ public Entity Find(Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7>
     public Entity Find(Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -303,6 +332,7 @@ public Entity Find(Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7> c
     public Entity Find(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -313,6 +343,7 @@ public Entity Find(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, bool> callb
     public Entity Find(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -323,6 +354,7 @@ public Entity Find(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, boo
     public Entity Find(delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 }
\ No newline at end of file
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/Query/Query.IIterable/T9.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/Query/Query.IIterable/T9.g.cs
index 90864e97..0ea80fac 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/Query/Query.IIterable/T9.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/Query/Query.IIterable/T9.g.cs
@@ -13,6 +13,7 @@ public unsafe partial struct Query<T0, T1, T2, T3, T4, T5, T6, T7, T8>
     public void Run(Ecs.RunCallback callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Run(ref this, callback);
     }
 
@@ -23,6 +24,7 @@ public void Run(Ecs.RunCallback callback)
     public void Run(delegate*<Iter, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Run(ref this, callback);
     }
 
@@ -33,6 +35,7 @@ public void Run(delegate*<Iter, void> callback)
     public void Iter(Ecs.IterFieldCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -43,6 +46,7 @@ public void Iter(Ecs.IterFieldCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> callb
     public void Iter(Ecs.IterSpanCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -53,6 +57,7 @@ public void Iter(Ecs.IterSpanCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> callba
     public void Iter(Ecs.IterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -63,6 +68,7 @@ public void Iter(Ecs.IterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> cal
     public void Iter(delegate*<Iter, Field<T0>, Field<T1>, Field<T2>, Field<T3>, Field<T4>, Field<T5>, Field<T6>, Field<T7>, Field<T8>, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -73,6 +79,7 @@ public void Iter(delegate*<Iter, Field<T0>, Field<T1>, Field<T2>, Field<T3>, Fie
     public void Iter(delegate*<Iter, Span<T0>, Span<T1>, Span<T2>, Span<T3>, Span<T4>, Span<T5>, Span<T6>, Span<T7>, Span<T8>, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -83,6 +90,7 @@ public void Iter(delegate*<Iter, Span<T0>, Span<T1>, Span<T2>, Span<T3>, Span<T4
     public void Iter(delegate*<Iter, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -93,6 +101,7 @@ public void Iter(delegate*<Iter, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, vo
     public void Each(Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -103,6 +112,7 @@ public void Each(Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> callbac
     public void Each(Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -113,6 +123,7 @@ public void Each(Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> c
     public void Each(Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -123,6 +134,7 @@ public void Each(Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> cal
     public void Each(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -133,6 +145,7 @@ public void Each(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T
     public void Each(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -143,6 +156,7 @@ public void Each(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T
     public void Each(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -153,6 +167,7 @@ public void Each(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, re
     public void Each(Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -163,6 +178,7 @@ public void Each(Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> cal
     public void Each(Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -173,6 +189,7 @@ public void Each(Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T
     public void Each(Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -183,6 +200,7 @@ public void Each(Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8>
     public void Each(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -193,6 +211,7 @@ public void Each(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, void> ca
     public void Each(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -203,6 +222,7 @@ public void Each(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*,
     public void Each(delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -213,6 +233,7 @@ public void Each(delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8
     public Entity Find(Ecs.FindRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -223,6 +244,7 @@ public Entity Find(Ecs.FindRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> callb
     public Entity Find(Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -233,6 +255,7 @@ public Entity Find(Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8>
     public Entity Find(Ecs.FindIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -243,6 +266,7 @@ public Entity Find(Ecs.FindIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> c
     public Entity Find(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -253,6 +277,7 @@ public Entity Find(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref
     public Entity Find(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -263,6 +288,7 @@ public Entity Find(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref
     public Entity Find(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -273,6 +299,7 @@ public Entity Find(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4,
     public Entity Find(Ecs.FindPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -283,6 +310,7 @@ public Entity Find(Ecs.FindPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> c
     public Entity Find(Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -293,6 +321,7 @@ public Entity Find(Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7,
     public Entity Find(Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -303,6 +332,7 @@ public Entity Find(Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T
     public Entity Find(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -313,6 +343,7 @@ public Entity Find(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, bool>
     public Entity Find(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -323,6 +354,7 @@ public Entity Find(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*
     public Entity Find(delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 }
\ No newline at end of file
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/Query/Query/T1.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/Query/Query/T1.g.cs
index 80079f08..ba2c691f 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/Query/Query/T1.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/Query/Query/T1.g.cs
@@ -199,6 +199,9 @@ public World RealWorld()
 // IIterableBase Interface
 public unsafe partial struct Query<T0> : IIterableBase
 {
+    /// <inheritdoc cref="IIterableBase.World"/>
+    ref ecs_world_t* IIterableBase.World => ref Ecs.GetIterableWorld(ref _query);
+
     /// <inheritdoc cref="Query.GetIter(ecs_world_t*)"/>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public ecs_iter_t GetIter(ecs_world_t* world = null)
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/Query/Query/T10.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/Query/Query/T10.g.cs
index cf7cca17..5bd89fd0 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/Query/Query/T10.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/Query/Query/T10.g.cs
@@ -199,6 +199,9 @@ public World RealWorld()
 // IIterableBase Interface
 public unsafe partial struct Query<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> : IIterableBase
 {
+    /// <inheritdoc cref="IIterableBase.World"/>
+    ref ecs_world_t* IIterableBase.World => ref Ecs.GetIterableWorld(ref _query);
+
     /// <inheritdoc cref="Query.GetIter(ecs_world_t*)"/>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public ecs_iter_t GetIter(ecs_world_t* world = null)
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/Query/Query/T11.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/Query/Query/T11.g.cs
index 83dacf62..440149d3 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/Query/Query/T11.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/Query/Query/T11.g.cs
@@ -199,6 +199,9 @@ public World RealWorld()
 // IIterableBase Interface
 public unsafe partial struct Query<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> : IIterableBase
 {
+    /// <inheritdoc cref="IIterableBase.World"/>
+    ref ecs_world_t* IIterableBase.World => ref Ecs.GetIterableWorld(ref _query);
+
     /// <inheritdoc cref="Query.GetIter(ecs_world_t*)"/>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public ecs_iter_t GetIter(ecs_world_t* world = null)
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/Query/Query/T12.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/Query/Query/T12.g.cs
index 576fa80b..bf7582c9 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/Query/Query/T12.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/Query/Query/T12.g.cs
@@ -199,6 +199,9 @@ public World RealWorld()
 // IIterableBase Interface
 public unsafe partial struct Query<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> : IIterableBase
 {
+    /// <inheritdoc cref="IIterableBase.World"/>
+    ref ecs_world_t* IIterableBase.World => ref Ecs.GetIterableWorld(ref _query);
+
     /// <inheritdoc cref="Query.GetIter(ecs_world_t*)"/>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public ecs_iter_t GetIter(ecs_world_t* world = null)
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/Query/Query/T13.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/Query/Query/T13.g.cs
index cbbfb8fc..421020bd 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/Query/Query/T13.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/Query/Query/T13.g.cs
@@ -199,6 +199,9 @@ public World RealWorld()
 // IIterableBase Interface
 public unsafe partial struct Query<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> : IIterableBase
 {
+    /// <inheritdoc cref="IIterableBase.World"/>
+    ref ecs_world_t* IIterableBase.World => ref Ecs.GetIterableWorld(ref _query);
+
     /// <inheritdoc cref="Query.GetIter(ecs_world_t*)"/>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public ecs_iter_t GetIter(ecs_world_t* world = null)
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/Query/Query/T14.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/Query/Query/T14.g.cs
index bc388223..83189af5 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/Query/Query/T14.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/Query/Query/T14.g.cs
@@ -199,6 +199,9 @@ public World RealWorld()
 // IIterableBase Interface
 public unsafe partial struct Query<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> : IIterableBase
 {
+    /// <inheritdoc cref="IIterableBase.World"/>
+    ref ecs_world_t* IIterableBase.World => ref Ecs.GetIterableWorld(ref _query);
+
     /// <inheritdoc cref="Query.GetIter(ecs_world_t*)"/>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public ecs_iter_t GetIter(ecs_world_t* world = null)
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/Query/Query/T15.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/Query/Query/T15.g.cs
index 7d48bd89..0ae9fa14 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/Query/Query/T15.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/Query/Query/T15.g.cs
@@ -199,6 +199,9 @@ public World RealWorld()
 // IIterableBase Interface
 public unsafe partial struct Query<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> : IIterableBase
 {
+    /// <inheritdoc cref="IIterableBase.World"/>
+    ref ecs_world_t* IIterableBase.World => ref Ecs.GetIterableWorld(ref _query);
+
     /// <inheritdoc cref="Query.GetIter(ecs_world_t*)"/>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public ecs_iter_t GetIter(ecs_world_t* world = null)
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/Query/Query/T16.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/Query/Query/T16.g.cs
index a028f133..7adfc7e3 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/Query/Query/T16.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/Query/Query/T16.g.cs
@@ -199,6 +199,9 @@ public World RealWorld()
 // IIterableBase Interface
 public unsafe partial struct Query<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> : IIterableBase
 {
+    /// <inheritdoc cref="IIterableBase.World"/>
+    ref ecs_world_t* IIterableBase.World => ref Ecs.GetIterableWorld(ref _query);
+
     /// <inheritdoc cref="Query.GetIter(ecs_world_t*)"/>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public ecs_iter_t GetIter(ecs_world_t* world = null)
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/Query/Query/T2.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/Query/Query/T2.g.cs
index f789c0a5..eb869e32 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/Query/Query/T2.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/Query/Query/T2.g.cs
@@ -199,6 +199,9 @@ public World RealWorld()
 // IIterableBase Interface
 public unsafe partial struct Query<T0, T1> : IIterableBase
 {
+    /// <inheritdoc cref="IIterableBase.World"/>
+    ref ecs_world_t* IIterableBase.World => ref Ecs.GetIterableWorld(ref _query);
+
     /// <inheritdoc cref="Query.GetIter(ecs_world_t*)"/>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public ecs_iter_t GetIter(ecs_world_t* world = null)
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/Query/Query/T3.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/Query/Query/T3.g.cs
index 7c696eaf..d4274935 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/Query/Query/T3.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/Query/Query/T3.g.cs
@@ -199,6 +199,9 @@ public World RealWorld()
 // IIterableBase Interface
 public unsafe partial struct Query<T0, T1, T2> : IIterableBase
 {
+    /// <inheritdoc cref="IIterableBase.World"/>
+    ref ecs_world_t* IIterableBase.World => ref Ecs.GetIterableWorld(ref _query);
+
     /// <inheritdoc cref="Query.GetIter(ecs_world_t*)"/>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public ecs_iter_t GetIter(ecs_world_t* world = null)
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/Query/Query/T4.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/Query/Query/T4.g.cs
index 4ca3cac2..4ad36e0e 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/Query/Query/T4.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/Query/Query/T4.g.cs
@@ -199,6 +199,9 @@ public World RealWorld()
 // IIterableBase Interface
 public unsafe partial struct Query<T0, T1, T2, T3> : IIterableBase
 {
+    /// <inheritdoc cref="IIterableBase.World"/>
+    ref ecs_world_t* IIterableBase.World => ref Ecs.GetIterableWorld(ref _query);
+
     /// <inheritdoc cref="Query.GetIter(ecs_world_t*)"/>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public ecs_iter_t GetIter(ecs_world_t* world = null)
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/Query/Query/T5.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/Query/Query/T5.g.cs
index 53c3e804..ec46a034 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/Query/Query/T5.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/Query/Query/T5.g.cs
@@ -199,6 +199,9 @@ public World RealWorld()
 // IIterableBase Interface
 public unsafe partial struct Query<T0, T1, T2, T3, T4> : IIterableBase
 {
+    /// <inheritdoc cref="IIterableBase.World"/>
+    ref ecs_world_t* IIterableBase.World => ref Ecs.GetIterableWorld(ref _query);
+
     /// <inheritdoc cref="Query.GetIter(ecs_world_t*)"/>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public ecs_iter_t GetIter(ecs_world_t* world = null)
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/Query/Query/T6.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/Query/Query/T6.g.cs
index 9c111d8d..29424c5d 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/Query/Query/T6.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/Query/Query/T6.g.cs
@@ -199,6 +199,9 @@ public World RealWorld()
 // IIterableBase Interface
 public unsafe partial struct Query<T0, T1, T2, T3, T4, T5> : IIterableBase
 {
+    /// <inheritdoc cref="IIterableBase.World"/>
+    ref ecs_world_t* IIterableBase.World => ref Ecs.GetIterableWorld(ref _query);
+
     /// <inheritdoc cref="Query.GetIter(ecs_world_t*)"/>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public ecs_iter_t GetIter(ecs_world_t* world = null)
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/Query/Query/T7.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/Query/Query/T7.g.cs
index 5636b3cc..64f488b9 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/Query/Query/T7.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/Query/Query/T7.g.cs
@@ -199,6 +199,9 @@ public World RealWorld()
 // IIterableBase Interface
 public unsafe partial struct Query<T0, T1, T2, T3, T4, T5, T6> : IIterableBase
 {
+    /// <inheritdoc cref="IIterableBase.World"/>
+    ref ecs_world_t* IIterableBase.World => ref Ecs.GetIterableWorld(ref _query);
+
     /// <inheritdoc cref="Query.GetIter(ecs_world_t*)"/>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public ecs_iter_t GetIter(ecs_world_t* world = null)
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/Query/Query/T8.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/Query/Query/T8.g.cs
index 9b4d127f..38eb7e36 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/Query/Query/T8.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/Query/Query/T8.g.cs
@@ -199,6 +199,9 @@ public World RealWorld()
 // IIterableBase Interface
 public unsafe partial struct Query<T0, T1, T2, T3, T4, T5, T6, T7> : IIterableBase
 {
+    /// <inheritdoc cref="IIterableBase.World"/>
+    ref ecs_world_t* IIterableBase.World => ref Ecs.GetIterableWorld(ref _query);
+
     /// <inheritdoc cref="Query.GetIter(ecs_world_t*)"/>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public ecs_iter_t GetIter(ecs_world_t* world = null)
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/Query/Query/T9.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/Query/Query/T9.g.cs
index 9a480e6e..6c4fc2d0 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/Query/Query/T9.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/Query/Query/T9.g.cs
@@ -199,6 +199,9 @@ public World RealWorld()
 // IIterableBase Interface
 public unsafe partial struct Query<T0, T1, T2, T3, T4, T5, T6, T7, T8> : IIterableBase
 {
+    /// <inheritdoc cref="IIterableBase.World"/>
+    ref ecs_world_t* IIterableBase.World => ref Ecs.GetIterableWorld(ref _query);
+
     /// <inheritdoc cref="Query.GetIter(ecs_world_t*)"/>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public ecs_iter_t GetIter(ecs_world_t* world = null)
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/SystemBuilder/SystemBuilder.NodeBuilder/T1.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/SystemBuilder/SystemBuilder.NodeBuilder/T1.g.cs
index 7e6746e0..32661668 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/SystemBuilder/SystemBuilder.NodeBuilder/T1.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/SystemBuilder/SystemBuilder.NodeBuilder/T1.g.cs
@@ -14,6 +14,7 @@ public unsafe partial struct SystemBuilder<T0>
     public System<T0> Run(Ecs.RunCallback callback)
     {
         TypeHelper<T0>.AssertReferenceTypes(true);
+        TypeHelper<T0>.AssertSparseTypes(World, true);
         return SetRun(callback, Pointers<T0>.RunCallbackDelegate).Build();
     }
 
@@ -24,6 +25,7 @@ public System<T0> Run(Ecs.RunCallback callback)
     public System<T0> Run(delegate*<Iter, void> callback)
     {
         TypeHelper<T0>.AssertReferenceTypes(true);
+        TypeHelper<T0>.AssertSparseTypes(World, true);
         return SetRun((IntPtr)callback, Pointers<T0>.RunCallbackPointer).Build();
     }
 
@@ -34,6 +36,7 @@ public System<T0> Run(delegate*<Iter, void> callback)
     public System<T0> Iter(Ecs.IterFieldCallback<T0> callback)
     {
         TypeHelper<T0>.AssertReferenceTypes(true);
+        TypeHelper<T0>.AssertSparseTypes(World, false);
         return SetCallback(callback, Pointers<T0>.IterFieldCallbackDelegate).Build();
     }
 
@@ -44,6 +47,7 @@ public System<T0> Iter(Ecs.IterFieldCallback<T0> callback)
     public System<T0> Iter(Ecs.IterSpanCallback<T0> callback)
     {
         TypeHelper<T0>.AssertReferenceTypes(false);
+        TypeHelper<T0>.AssertSparseTypes(World, false);
         return SetCallback(callback, Pointers<T0>.IterSpanCallbackDelegate).Build();
     }
 
@@ -54,6 +58,7 @@ public System<T0> Iter(Ecs.IterSpanCallback<T0> callback)
     public System<T0> Iter(Ecs.IterPointerCallback<T0> callback)
     {
         TypeHelper<T0>.AssertReferenceTypes(false);
+        TypeHelper<T0>.AssertSparseTypes(World, false);
         return SetCallback(callback, Pointers<T0>.IterPointerCallbackDelegate).Build();
     }
 
@@ -64,6 +69,7 @@ public System<T0> Iter(Ecs.IterPointerCallback<T0> callback)
     public System<T0> Iter(delegate*<Iter, Field<T0>, void> callback)
     {
         TypeHelper<T0>.AssertReferenceTypes(true);
+        TypeHelper<T0>.AssertSparseTypes(World, false);
         return SetCallback((IntPtr)callback, Pointers<T0>.IterFieldCallbackPointer).Build();
     }
 
@@ -74,6 +80,7 @@ public System<T0> Iter(delegate*<Iter, Field<T0>, void> callback)
     public System<T0> Iter(delegate*<Iter, Span<T0>, void> callback)
     {
         TypeHelper<T0>.AssertReferenceTypes(false);
+        TypeHelper<T0>.AssertSparseTypes(World, false);
         return SetCallback((IntPtr)callback, Pointers<T0>.IterSpanCallbackPointer).Build();
     }
 
@@ -84,6 +91,7 @@ public System<T0> Iter(delegate*<Iter, Span<T0>, void> callback)
     public System<T0> Iter(delegate*<Iter, T0*, void> callback)
     {
         TypeHelper<T0>.AssertReferenceTypes(false);
+        TypeHelper<T0>.AssertSparseTypes(World, false);
         return SetCallback((IntPtr)callback, Pointers<T0>.IterPointerCallbackPointer).Build();
     }
 
@@ -94,6 +102,7 @@ public System<T0> Iter(delegate*<Iter, T0*, void> callback)
     public System<T0> Each(Ecs.EachRefCallback<T0> callback)
     {
         TypeHelper<T0>.AssertReferenceTypes(true);
+        TypeHelper<T0>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0>.EachRefCallbackDelegate).Build();
     }
 
@@ -104,6 +113,7 @@ public System<T0> Each(Ecs.EachRefCallback<T0> callback)
     public System<T0> Each(Ecs.EachEntityRefCallback<T0> callback)
     {
         TypeHelper<T0>.AssertReferenceTypes(true);
+        TypeHelper<T0>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0>.EachEntityRefCallbackDelegate).Build();
     }
 
@@ -114,6 +124,7 @@ public System<T0> Each(Ecs.EachEntityRefCallback<T0> callback)
     public System<T0> Each(Ecs.EachIterRefCallback<T0> callback)
     {
         TypeHelper<T0>.AssertReferenceTypes(true);
+        TypeHelper<T0>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0>.EachIterRefCallbackDelegate).Build();
     }
 
@@ -124,6 +135,7 @@ public System<T0> Each(Ecs.EachIterRefCallback<T0> callback)
     public System<T0> Each(delegate*<ref T0, void> callback)
     {
         TypeHelper<T0>.AssertReferenceTypes(true);
+        TypeHelper<T0>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0>.EachRefCallbackPointer).Build();
     }
 
@@ -134,6 +146,7 @@ public System<T0> Each(delegate*<ref T0, void> callback)
     public System<T0> Each(delegate*<Entity, ref T0, void> callback)
     {
         TypeHelper<T0>.AssertReferenceTypes(true);
+        TypeHelper<T0>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0>.EachEntityRefCallbackPointer).Build();
     }
 
@@ -144,6 +157,7 @@ public System<T0> Each(delegate*<Entity, ref T0, void> callback)
     public System<T0> Each(delegate*<Iter, int, ref T0, void> callback)
     {
         TypeHelper<T0>.AssertReferenceTypes(true);
+        TypeHelper<T0>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0>.EachIterRefCallbackPointer).Build();
     }
 
@@ -154,6 +168,7 @@ public System<T0> Each(delegate*<Iter, int, ref T0, void> callback)
     public System<T0> Each(Ecs.EachPointerCallback<T0> callback)
     {
         TypeHelper<T0>.AssertReferenceTypes(false);
+        TypeHelper<T0>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0>.EachPointerCallbackDelegate).Build();
     }
 
@@ -164,6 +179,7 @@ public System<T0> Each(Ecs.EachPointerCallback<T0> callback)
     public System<T0> Each(Ecs.EachEntityPointerCallback<T0> callback)
     {
         TypeHelper<T0>.AssertReferenceTypes(false);
+        TypeHelper<T0>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0>.EachEntityPointerCallbackDelegate).Build();
     }
 
@@ -174,6 +190,7 @@ public System<T0> Each(Ecs.EachEntityPointerCallback<T0> callback)
     public System<T0> Each(Ecs.EachIterPointerCallback<T0> callback)
     {
         TypeHelper<T0>.AssertReferenceTypes(false);
+        TypeHelper<T0>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0>.EachIterPointerCallbackDelegate).Build();
     }
 
@@ -184,6 +201,7 @@ public System<T0> Each(Ecs.EachIterPointerCallback<T0> callback)
     public System<T0> Each(delegate*<T0*, void> callback)
     {
         TypeHelper<T0>.AssertReferenceTypes(false);
+        TypeHelper<T0>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0>.EachPointerCallbackPointer).Build();
     }
 
@@ -194,6 +212,7 @@ public System<T0> Each(delegate*<T0*, void> callback)
     public System<T0> Each(delegate*<Entity, T0*, void> callback)
     {
         TypeHelper<T0>.AssertReferenceTypes(false);
+        TypeHelper<T0>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0>.EachEntityPointerCallbackPointer).Build();
     }
 
@@ -204,6 +223,7 @@ public System<T0> Each(delegate*<Entity, T0*, void> callback)
     public System<T0> Each(delegate*<Iter, int, T0*, void> callback)
     {
         TypeHelper<T0>.AssertReferenceTypes(false);
+        TypeHelper<T0>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0>.EachIterPointerCallbackPointer).Build();
     }
 }
\ No newline at end of file
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/SystemBuilder/SystemBuilder.NodeBuilder/T10.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/SystemBuilder/SystemBuilder.NodeBuilder/T10.g.cs
index 648dfc9c..1e299599 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/SystemBuilder/SystemBuilder.NodeBuilder/T10.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/SystemBuilder/SystemBuilder.NodeBuilder/T10.g.cs
@@ -14,6 +14,7 @@ public unsafe partial struct SystemBuilder<T0, T1, T2, T3, T4, T5, T6, T7, T8, T
     public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Run(Ecs.RunCallback callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertSparseTypes(World, true);
         return SetRun(callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.RunCallbackDelegate).Build();
     }
 
@@ -24,6 +25,7 @@ public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Run(Ecs.RunCallback callba
     public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Run(delegate*<Iter, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertSparseTypes(World, true);
         return SetRun((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.RunCallbackPointer).Build();
     }
 
@@ -34,6 +36,7 @@ public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Run(delegate*<Iter, void>
     public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Iter(Ecs.IterFieldCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertSparseTypes(World, false);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.IterFieldCallbackDelegate).Build();
     }
 
@@ -44,6 +47,7 @@ public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Iter(Ecs.IterFieldCallback
     public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Iter(Ecs.IterSpanCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertSparseTypes(World, false);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.IterSpanCallbackDelegate).Build();
     }
 
@@ -54,6 +58,7 @@ public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Iter(Ecs.IterSpanCallback<
     public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Iter(Ecs.IterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertSparseTypes(World, false);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.IterPointerCallbackDelegate).Build();
     }
 
@@ -64,6 +69,7 @@ public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Iter(Ecs.IterPointerCallba
     public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Iter(delegate*<Iter, Field<T0>, Field<T1>, Field<T2>, Field<T3>, Field<T4>, Field<T5>, Field<T6>, Field<T7>, Field<T8>, Field<T9>, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertSparseTypes(World, false);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.IterFieldCallbackPointer).Build();
     }
 
@@ -74,6 +80,7 @@ public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Iter(delegate*<Iter, Field
     public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Iter(delegate*<Iter, Span<T0>, Span<T1>, Span<T2>, Span<T3>, Span<T4>, Span<T5>, Span<T6>, Span<T7>, Span<T8>, Span<T9>, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertSparseTypes(World, false);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.IterSpanCallbackPointer).Build();
     }
 
@@ -84,6 +91,7 @@ public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Iter(delegate*<Iter, Span<
     public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Iter(delegate*<Iter, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertSparseTypes(World, false);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.IterPointerCallbackPointer).Build();
     }
 
@@ -94,6 +102,7 @@ public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Iter(delegate*<Iter, T0*,
     public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Each(Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.EachRefCallbackDelegate).Build();
     }
 
@@ -104,6 +113,7 @@ public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Each(Ecs.EachRefCallback<T
     public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Each(Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.EachEntityRefCallbackDelegate).Build();
     }
 
@@ -114,6 +124,7 @@ public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Each(Ecs.EachEntityRefCall
     public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Each(Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.EachIterRefCallbackDelegate).Build();
     }
 
@@ -124,6 +135,7 @@ public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Each(Ecs.EachIterRefCallba
     public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Each(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.EachRefCallbackPointer).Build();
     }
 
@@ -134,6 +146,7 @@ public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Each(delegate*<ref T0, ref
     public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Each(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.EachEntityRefCallbackPointer).Build();
     }
 
@@ -144,6 +157,7 @@ public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Each(delegate*<Entity, ref
     public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Each(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.EachIterRefCallbackPointer).Build();
     }
 
@@ -154,6 +168,7 @@ public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Each(delegate*<Iter, int,
     public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Each(Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.EachPointerCallbackDelegate).Build();
     }
 
@@ -164,6 +179,7 @@ public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Each(Ecs.EachPointerCallba
     public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Each(Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.EachEntityPointerCallbackDelegate).Build();
     }
 
@@ -174,6 +190,7 @@ public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Each(Ecs.EachEntityPointer
     public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Each(Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.EachIterPointerCallbackDelegate).Build();
     }
 
@@ -184,6 +201,7 @@ public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Each(Ecs.EachIterPointerCa
     public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Each(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.EachPointerCallbackPointer).Build();
     }
 
@@ -194,6 +212,7 @@ public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Each(delegate*<T0*, T1*, T
     public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Each(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.EachEntityPointerCallbackPointer).Build();
     }
 
@@ -204,6 +223,7 @@ public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Each(delegate*<Entity, T0*
     public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Each(delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.EachIterPointerCallbackPointer).Build();
     }
 }
\ No newline at end of file
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/SystemBuilder/SystemBuilder.NodeBuilder/T11.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/SystemBuilder/SystemBuilder.NodeBuilder/T11.g.cs
index 56455e9a..33d186fc 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/SystemBuilder/SystemBuilder.NodeBuilder/T11.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/SystemBuilder/SystemBuilder.NodeBuilder/T11.g.cs
@@ -14,6 +14,7 @@ public unsafe partial struct SystemBuilder<T0, T1, T2, T3, T4, T5, T6, T7, T8, T
     public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Run(Ecs.RunCallback callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertSparseTypes(World, true);
         return SetRun(callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.RunCallbackDelegate).Build();
     }
 
@@ -24,6 +25,7 @@ public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Run(Ecs.RunCallback c
     public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Run(delegate*<Iter, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertSparseTypes(World, true);
         return SetRun((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.RunCallbackPointer).Build();
     }
 
@@ -34,6 +36,7 @@ public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Run(delegate*<Iter, v
     public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Iter(Ecs.IterFieldCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertSparseTypes(World, false);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.IterFieldCallbackDelegate).Build();
     }
 
@@ -44,6 +47,7 @@ public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Iter(Ecs.IterFieldCal
     public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Iter(Ecs.IterSpanCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertSparseTypes(World, false);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.IterSpanCallbackDelegate).Build();
     }
 
@@ -54,6 +58,7 @@ public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Iter(Ecs.IterSpanCall
     public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Iter(Ecs.IterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertSparseTypes(World, false);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.IterPointerCallbackDelegate).Build();
     }
 
@@ -64,6 +69,7 @@ public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Iter(Ecs.IterPointerC
     public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Iter(delegate*<Iter, Field<T0>, Field<T1>, Field<T2>, Field<T3>, Field<T4>, Field<T5>, Field<T6>, Field<T7>, Field<T8>, Field<T9>, Field<T10>, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertSparseTypes(World, false);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.IterFieldCallbackPointer).Build();
     }
 
@@ -74,6 +80,7 @@ public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Iter(delegate*<Iter,
     public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Iter(delegate*<Iter, Span<T0>, Span<T1>, Span<T2>, Span<T3>, Span<T4>, Span<T5>, Span<T6>, Span<T7>, Span<T8>, Span<T9>, Span<T10>, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertSparseTypes(World, false);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.IterSpanCallbackPointer).Build();
     }
 
@@ -84,6 +91,7 @@ public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Iter(delegate*<Iter,
     public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Iter(delegate*<Iter, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertSparseTypes(World, false);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.IterPointerCallbackPointer).Build();
     }
 
@@ -94,6 +102,7 @@ public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Iter(delegate*<Iter,
     public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Each(Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.EachRefCallbackDelegate).Build();
     }
 
@@ -104,6 +113,7 @@ public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Each(Ecs.EachRefCallb
     public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Each(Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.EachEntityRefCallbackDelegate).Build();
     }
 
@@ -114,6 +124,7 @@ public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Each(Ecs.EachEntityRe
     public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Each(Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.EachIterRefCallbackDelegate).Build();
     }
 
@@ -124,6 +135,7 @@ public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Each(Ecs.EachIterRefC
     public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Each(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.EachRefCallbackPointer).Build();
     }
 
@@ -134,6 +146,7 @@ public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Each(delegate*<ref T0
     public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Each(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.EachEntityRefCallbackPointer).Build();
     }
 
@@ -144,6 +157,7 @@ public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Each(delegate*<Entity
     public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Each(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.EachIterRefCallbackPointer).Build();
     }
 
@@ -154,6 +168,7 @@ public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Each(delegate*<Iter,
     public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Each(Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.EachPointerCallbackDelegate).Build();
     }
 
@@ -164,6 +179,7 @@ public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Each(Ecs.EachPointerC
     public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Each(Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.EachEntityPointerCallbackDelegate).Build();
     }
 
@@ -174,6 +190,7 @@ public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Each(Ecs.EachEntityPo
     public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Each(Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.EachIterPointerCallbackDelegate).Build();
     }
 
@@ -184,6 +201,7 @@ public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Each(Ecs.EachIterPoin
     public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Each(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.EachPointerCallbackPointer).Build();
     }
 
@@ -194,6 +212,7 @@ public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Each(delegate*<T0*, T
     public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Each(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.EachEntityPointerCallbackPointer).Build();
     }
 
@@ -204,6 +223,7 @@ public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Each(delegate*<Entity
     public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Each(delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.EachIterPointerCallbackPointer).Build();
     }
 }
\ No newline at end of file
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/SystemBuilder/SystemBuilder.NodeBuilder/T12.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/SystemBuilder/SystemBuilder.NodeBuilder/T12.g.cs
index 559a4b80..66da096f 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/SystemBuilder/SystemBuilder.NodeBuilder/T12.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/SystemBuilder/SystemBuilder.NodeBuilder/T12.g.cs
@@ -14,6 +14,7 @@ public unsafe partial struct SystemBuilder<T0, T1, T2, T3, T4, T5, T6, T7, T8, T
     public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Run(Ecs.RunCallback callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertSparseTypes(World, true);
         return SetRun(callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.RunCallbackDelegate).Build();
     }
 
@@ -24,6 +25,7 @@ public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Run(Ecs.RunCallb
     public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Run(delegate*<Iter, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertSparseTypes(World, true);
         return SetRun((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.RunCallbackPointer).Build();
     }
 
@@ -34,6 +36,7 @@ public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Run(delegate*<It
     public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Iter(Ecs.IterFieldCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertSparseTypes(World, false);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.IterFieldCallbackDelegate).Build();
     }
 
@@ -44,6 +47,7 @@ public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Iter(Ecs.IterFie
     public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Iter(Ecs.IterSpanCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertSparseTypes(World, false);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.IterSpanCallbackDelegate).Build();
     }
 
@@ -54,6 +58,7 @@ public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Iter(Ecs.IterSpa
     public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Iter(Ecs.IterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertSparseTypes(World, false);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.IterPointerCallbackDelegate).Build();
     }
 
@@ -64,6 +69,7 @@ public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Iter(Ecs.IterPoi
     public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Iter(delegate*<Iter, Field<T0>, Field<T1>, Field<T2>, Field<T3>, Field<T4>, Field<T5>, Field<T6>, Field<T7>, Field<T8>, Field<T9>, Field<T10>, Field<T11>, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertSparseTypes(World, false);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.IterFieldCallbackPointer).Build();
     }
 
@@ -74,6 +80,7 @@ public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Iter(delegate*<I
     public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Iter(delegate*<Iter, Span<T0>, Span<T1>, Span<T2>, Span<T3>, Span<T4>, Span<T5>, Span<T6>, Span<T7>, Span<T8>, Span<T9>, Span<T10>, Span<T11>, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertSparseTypes(World, false);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.IterSpanCallbackPointer).Build();
     }
 
@@ -84,6 +91,7 @@ public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Iter(delegate*<I
     public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Iter(delegate*<Iter, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertSparseTypes(World, false);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.IterPointerCallbackPointer).Build();
     }
 
@@ -94,6 +102,7 @@ public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Iter(delegate*<I
     public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Each(Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.EachRefCallbackDelegate).Build();
     }
 
@@ -104,6 +113,7 @@ public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Each(Ecs.EachRef
     public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Each(Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.EachEntityRefCallbackDelegate).Build();
     }
 
@@ -114,6 +124,7 @@ public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Each(Ecs.EachEnt
     public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Each(Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.EachIterRefCallbackDelegate).Build();
     }
 
@@ -124,6 +135,7 @@ public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Each(Ecs.EachIte
     public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Each(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.EachRefCallbackPointer).Build();
     }
 
@@ -134,6 +146,7 @@ public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Each(delegate*<r
     public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Each(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.EachEntityRefCallbackPointer).Build();
     }
 
@@ -144,6 +157,7 @@ public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Each(delegate*<E
     public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Each(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.EachIterRefCallbackPointer).Build();
     }
 
@@ -154,6 +168,7 @@ public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Each(delegate*<I
     public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Each(Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.EachPointerCallbackDelegate).Build();
     }
 
@@ -164,6 +179,7 @@ public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Each(Ecs.EachPoi
     public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Each(Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.EachEntityPointerCallbackDelegate).Build();
     }
 
@@ -174,6 +190,7 @@ public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Each(Ecs.EachEnt
     public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Each(Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.EachIterPointerCallbackDelegate).Build();
     }
 
@@ -184,6 +201,7 @@ public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Each(Ecs.EachIte
     public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Each(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.EachPointerCallbackPointer).Build();
     }
 
@@ -194,6 +212,7 @@ public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Each(delegate*<T
     public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Each(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.EachEntityPointerCallbackPointer).Build();
     }
 
@@ -204,6 +223,7 @@ public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Each(delegate*<E
     public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Each(delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.EachIterPointerCallbackPointer).Build();
     }
 }
\ No newline at end of file
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/SystemBuilder/SystemBuilder.NodeBuilder/T13.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/SystemBuilder/SystemBuilder.NodeBuilder/T13.g.cs
index 7d4d51f9..88a80c7d 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/SystemBuilder/SystemBuilder.NodeBuilder/T13.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/SystemBuilder/SystemBuilder.NodeBuilder/T13.g.cs
@@ -14,6 +14,7 @@ public unsafe partial struct SystemBuilder<T0, T1, T2, T3, T4, T5, T6, T7, T8, T
     public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> Run(Ecs.RunCallback callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertSparseTypes(World, true);
         return SetRun(callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.RunCallbackDelegate).Build();
     }
 
@@ -24,6 +25,7 @@ public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> Run(Ecs.Run
     public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> Run(delegate*<Iter, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertSparseTypes(World, true);
         return SetRun((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.RunCallbackPointer).Build();
     }
 
@@ -34,6 +36,7 @@ public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> Run(delegat
     public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> Iter(Ecs.IterFieldCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertSparseTypes(World, false);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.IterFieldCallbackDelegate).Build();
     }
 
@@ -44,6 +47,7 @@ public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> Iter(Ecs.It
     public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> Iter(Ecs.IterSpanCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertSparseTypes(World, false);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.IterSpanCallbackDelegate).Build();
     }
 
@@ -54,6 +58,7 @@ public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> Iter(Ecs.It
     public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> Iter(Ecs.IterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertSparseTypes(World, false);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.IterPointerCallbackDelegate).Build();
     }
 
@@ -64,6 +69,7 @@ public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> Iter(Ecs.It
     public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> Iter(delegate*<Iter, Field<T0>, Field<T1>, Field<T2>, Field<T3>, Field<T4>, Field<T5>, Field<T6>, Field<T7>, Field<T8>, Field<T9>, Field<T10>, Field<T11>, Field<T12>, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertSparseTypes(World, false);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.IterFieldCallbackPointer).Build();
     }
 
@@ -74,6 +80,7 @@ public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> Iter(delega
     public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> Iter(delegate*<Iter, Span<T0>, Span<T1>, Span<T2>, Span<T3>, Span<T4>, Span<T5>, Span<T6>, Span<T7>, Span<T8>, Span<T9>, Span<T10>, Span<T11>, Span<T12>, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertSparseTypes(World, false);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.IterSpanCallbackPointer).Build();
     }
 
@@ -84,6 +91,7 @@ public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> Iter(delega
     public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> Iter(delegate*<Iter, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertSparseTypes(World, false);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.IterPointerCallbackPointer).Build();
     }
 
@@ -94,6 +102,7 @@ public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> Iter(delega
     public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> Each(Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.EachRefCallbackDelegate).Build();
     }
 
@@ -104,6 +113,7 @@ public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> Each(Ecs.Ea
     public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> Each(Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.EachEntityRefCallbackDelegate).Build();
     }
 
@@ -114,6 +124,7 @@ public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> Each(Ecs.Ea
     public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> Each(Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.EachIterRefCallbackDelegate).Build();
     }
 
@@ -124,6 +135,7 @@ public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> Each(Ecs.Ea
     public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> Each(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.EachRefCallbackPointer).Build();
     }
 
@@ -134,6 +146,7 @@ public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> Each(delega
     public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> Each(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.EachEntityRefCallbackPointer).Build();
     }
 
@@ -144,6 +157,7 @@ public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> Each(delega
     public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> Each(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.EachIterRefCallbackPointer).Build();
     }
 
@@ -154,6 +168,7 @@ public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> Each(delega
     public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> Each(Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.EachPointerCallbackDelegate).Build();
     }
 
@@ -164,6 +179,7 @@ public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> Each(Ecs.Ea
     public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> Each(Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.EachEntityPointerCallbackDelegate).Build();
     }
 
@@ -174,6 +190,7 @@ public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> Each(Ecs.Ea
     public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> Each(Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.EachIterPointerCallbackDelegate).Build();
     }
 
@@ -184,6 +201,7 @@ public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> Each(Ecs.Ea
     public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> Each(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.EachPointerCallbackPointer).Build();
     }
 
@@ -194,6 +212,7 @@ public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> Each(delega
     public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> Each(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.EachEntityPointerCallbackPointer).Build();
     }
 
@@ -204,6 +223,7 @@ public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> Each(delega
     public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> Each(delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.EachIterPointerCallbackPointer).Build();
     }
 }
\ No newline at end of file
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/SystemBuilder/SystemBuilder.NodeBuilder/T14.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/SystemBuilder/SystemBuilder.NodeBuilder/T14.g.cs
index 25dbee95..572e5e92 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/SystemBuilder/SystemBuilder.NodeBuilder/T14.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/SystemBuilder/SystemBuilder.NodeBuilder/T14.g.cs
@@ -14,6 +14,7 @@ public unsafe partial struct SystemBuilder<T0, T1, T2, T3, T4, T5, T6, T7, T8, T
     public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> Run(Ecs.RunCallback callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertSparseTypes(World, true);
         return SetRun(callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.RunCallbackDelegate).Build();
     }
 
@@ -24,6 +25,7 @@ public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> Run(Ec
     public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> Run(delegate*<Iter, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertSparseTypes(World, true);
         return SetRun((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.RunCallbackPointer).Build();
     }
 
@@ -34,6 +36,7 @@ public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> Run(de
     public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> Iter(Ecs.IterFieldCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertSparseTypes(World, false);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.IterFieldCallbackDelegate).Build();
     }
 
@@ -44,6 +47,7 @@ public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> Iter(E
     public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> Iter(Ecs.IterSpanCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertSparseTypes(World, false);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.IterSpanCallbackDelegate).Build();
     }
 
@@ -54,6 +58,7 @@ public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> Iter(E
     public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> Iter(Ecs.IterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertSparseTypes(World, false);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.IterPointerCallbackDelegate).Build();
     }
 
@@ -64,6 +69,7 @@ public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> Iter(E
     public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> Iter(delegate*<Iter, Field<T0>, Field<T1>, Field<T2>, Field<T3>, Field<T4>, Field<T5>, Field<T6>, Field<T7>, Field<T8>, Field<T9>, Field<T10>, Field<T11>, Field<T12>, Field<T13>, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertSparseTypes(World, false);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.IterFieldCallbackPointer).Build();
     }
 
@@ -74,6 +80,7 @@ public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> Iter(d
     public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> Iter(delegate*<Iter, Span<T0>, Span<T1>, Span<T2>, Span<T3>, Span<T4>, Span<T5>, Span<T6>, Span<T7>, Span<T8>, Span<T9>, Span<T10>, Span<T11>, Span<T12>, Span<T13>, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertSparseTypes(World, false);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.IterSpanCallbackPointer).Build();
     }
 
@@ -84,6 +91,7 @@ public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> Iter(d
     public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> Iter(delegate*<Iter, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertSparseTypes(World, false);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.IterPointerCallbackPointer).Build();
     }
 
@@ -94,6 +102,7 @@ public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> Iter(d
     public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> Each(Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.EachRefCallbackDelegate).Build();
     }
 
@@ -104,6 +113,7 @@ public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> Each(E
     public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> Each(Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.EachEntityRefCallbackDelegate).Build();
     }
 
@@ -114,6 +124,7 @@ public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> Each(E
     public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> Each(Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.EachIterRefCallbackDelegate).Build();
     }
 
@@ -124,6 +135,7 @@ public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> Each(E
     public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> Each(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.EachRefCallbackPointer).Build();
     }
 
@@ -134,6 +146,7 @@ public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> Each(d
     public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> Each(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.EachEntityRefCallbackPointer).Build();
     }
 
@@ -144,6 +157,7 @@ public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> Each(d
     public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> Each(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.EachIterRefCallbackPointer).Build();
     }
 
@@ -154,6 +168,7 @@ public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> Each(d
     public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> Each(Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.EachPointerCallbackDelegate).Build();
     }
 
@@ -164,6 +179,7 @@ public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> Each(E
     public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> Each(Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.EachEntityPointerCallbackDelegate).Build();
     }
 
@@ -174,6 +190,7 @@ public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> Each(E
     public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> Each(Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.EachIterPointerCallbackDelegate).Build();
     }
 
@@ -184,6 +201,7 @@ public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> Each(E
     public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> Each(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.EachPointerCallbackPointer).Build();
     }
 
@@ -194,6 +212,7 @@ public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> Each(d
     public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> Each(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.EachEntityPointerCallbackPointer).Build();
     }
 
@@ -204,6 +223,7 @@ public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> Each(d
     public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> Each(delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.EachIterPointerCallbackPointer).Build();
     }
 }
\ No newline at end of file
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/SystemBuilder/SystemBuilder.NodeBuilder/T15.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/SystemBuilder/SystemBuilder.NodeBuilder/T15.g.cs
index 2a794ef0..88f9b4ed 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/SystemBuilder/SystemBuilder.NodeBuilder/T15.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/SystemBuilder/SystemBuilder.NodeBuilder/T15.g.cs
@@ -14,6 +14,7 @@ public unsafe partial struct SystemBuilder<T0, T1, T2, T3, T4, T5, T6, T7, T8, T
     public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> Run(Ecs.RunCallback callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertSparseTypes(World, true);
         return SetRun(callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.RunCallbackDelegate).Build();
     }
 
@@ -24,6 +25,7 @@ public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> R
     public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> Run(delegate*<Iter, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertSparseTypes(World, true);
         return SetRun((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.RunCallbackPointer).Build();
     }
 
@@ -34,6 +36,7 @@ public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> R
     public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> Iter(Ecs.IterFieldCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertSparseTypes(World, false);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.IterFieldCallbackDelegate).Build();
     }
 
@@ -44,6 +47,7 @@ public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> I
     public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> Iter(Ecs.IterSpanCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertSparseTypes(World, false);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.IterSpanCallbackDelegate).Build();
     }
 
@@ -54,6 +58,7 @@ public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> I
     public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> Iter(Ecs.IterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertSparseTypes(World, false);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.IterPointerCallbackDelegate).Build();
     }
 
@@ -64,6 +69,7 @@ public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> I
     public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> Iter(delegate*<Iter, Field<T0>, Field<T1>, Field<T2>, Field<T3>, Field<T4>, Field<T5>, Field<T6>, Field<T7>, Field<T8>, Field<T9>, Field<T10>, Field<T11>, Field<T12>, Field<T13>, Field<T14>, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertSparseTypes(World, false);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.IterFieldCallbackPointer).Build();
     }
 
@@ -74,6 +80,7 @@ public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> I
     public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> Iter(delegate*<Iter, Span<T0>, Span<T1>, Span<T2>, Span<T3>, Span<T4>, Span<T5>, Span<T6>, Span<T7>, Span<T8>, Span<T9>, Span<T10>, Span<T11>, Span<T12>, Span<T13>, Span<T14>, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertSparseTypes(World, false);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.IterSpanCallbackPointer).Build();
     }
 
@@ -84,6 +91,7 @@ public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> I
     public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> Iter(delegate*<Iter, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, T14*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertSparseTypes(World, false);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.IterPointerCallbackPointer).Build();
     }
 
@@ -94,6 +102,7 @@ public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> I
     public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> Each(Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.EachRefCallbackDelegate).Build();
     }
 
@@ -104,6 +113,7 @@ public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> E
     public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> Each(Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.EachEntityRefCallbackDelegate).Build();
     }
 
@@ -114,6 +124,7 @@ public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> E
     public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> Each(Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.EachIterRefCallbackDelegate).Build();
     }
 
@@ -124,6 +135,7 @@ public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> E
     public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> Each(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, ref T14, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.EachRefCallbackPointer).Build();
     }
 
@@ -134,6 +146,7 @@ public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> E
     public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> Each(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, ref T14, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.EachEntityRefCallbackPointer).Build();
     }
 
@@ -144,6 +157,7 @@ public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> E
     public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> Each(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, ref T14, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.EachIterRefCallbackPointer).Build();
     }
 
@@ -154,6 +168,7 @@ public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> E
     public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> Each(Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.EachPointerCallbackDelegate).Build();
     }
 
@@ -164,6 +179,7 @@ public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> E
     public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> Each(Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.EachEntityPointerCallbackDelegate).Build();
     }
 
@@ -174,6 +190,7 @@ public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> E
     public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> Each(Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.EachIterPointerCallbackDelegate).Build();
     }
 
@@ -184,6 +201,7 @@ public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> E
     public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> Each(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, T14*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.EachPointerCallbackPointer).Build();
     }
 
@@ -194,6 +212,7 @@ public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> E
     public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> Each(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, T14*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.EachEntityPointerCallbackPointer).Build();
     }
 
@@ -204,6 +223,7 @@ public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> E
     public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> Each(delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, T14*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.EachIterPointerCallbackPointer).Build();
     }
 }
\ No newline at end of file
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/SystemBuilder/SystemBuilder.NodeBuilder/T16.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/SystemBuilder/SystemBuilder.NodeBuilder/T16.g.cs
index 8400ad4b..542666be 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/SystemBuilder/SystemBuilder.NodeBuilder/T16.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/SystemBuilder/SystemBuilder.NodeBuilder/T16.g.cs
@@ -14,6 +14,7 @@ public unsafe partial struct SystemBuilder<T0, T1, T2, T3, T4, T5, T6, T7, T8, T
     public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> Run(Ecs.RunCallback callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertSparseTypes(World, true);
         return SetRun(callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.RunCallbackDelegate).Build();
     }
 
@@ -24,6 +25,7 @@ public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T
     public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> Run(delegate*<Iter, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertSparseTypes(World, true);
         return SetRun((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.RunCallbackPointer).Build();
     }
 
@@ -34,6 +36,7 @@ public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T
     public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> Iter(Ecs.IterFieldCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertSparseTypes(World, false);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.IterFieldCallbackDelegate).Build();
     }
 
@@ -44,6 +47,7 @@ public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T
     public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> Iter(Ecs.IterSpanCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertSparseTypes(World, false);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.IterSpanCallbackDelegate).Build();
     }
 
@@ -54,6 +58,7 @@ public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T
     public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> Iter(Ecs.IterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertSparseTypes(World, false);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.IterPointerCallbackDelegate).Build();
     }
 
@@ -64,6 +69,7 @@ public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T
     public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> Iter(delegate*<Iter, Field<T0>, Field<T1>, Field<T2>, Field<T3>, Field<T4>, Field<T5>, Field<T6>, Field<T7>, Field<T8>, Field<T9>, Field<T10>, Field<T11>, Field<T12>, Field<T13>, Field<T14>, Field<T15>, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertSparseTypes(World, false);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.IterFieldCallbackPointer).Build();
     }
 
@@ -74,6 +80,7 @@ public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T
     public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> Iter(delegate*<Iter, Span<T0>, Span<T1>, Span<T2>, Span<T3>, Span<T4>, Span<T5>, Span<T6>, Span<T7>, Span<T8>, Span<T9>, Span<T10>, Span<T11>, Span<T12>, Span<T13>, Span<T14>, Span<T15>, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertSparseTypes(World, false);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.IterSpanCallbackPointer).Build();
     }
 
@@ -84,6 +91,7 @@ public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T
     public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> Iter(delegate*<Iter, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, T14*, T15*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertSparseTypes(World, false);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.IterPointerCallbackPointer).Build();
     }
 
@@ -94,6 +102,7 @@ public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T
     public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> Each(Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.EachRefCallbackDelegate).Build();
     }
 
@@ -104,6 +113,7 @@ public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T
     public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> Each(Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.EachEntityRefCallbackDelegate).Build();
     }
 
@@ -114,6 +124,7 @@ public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T
     public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> Each(Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.EachIterRefCallbackDelegate).Build();
     }
 
@@ -124,6 +135,7 @@ public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T
     public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> Each(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, ref T14, ref T15, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.EachRefCallbackPointer).Build();
     }
 
@@ -134,6 +146,7 @@ public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T
     public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> Each(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, ref T14, ref T15, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.EachEntityRefCallbackPointer).Build();
     }
 
@@ -144,6 +157,7 @@ public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T
     public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> Each(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, ref T14, ref T15, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.EachIterRefCallbackPointer).Build();
     }
 
@@ -154,6 +168,7 @@ public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T
     public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> Each(Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.EachPointerCallbackDelegate).Build();
     }
 
@@ -164,6 +179,7 @@ public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T
     public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> Each(Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.EachEntityPointerCallbackDelegate).Build();
     }
 
@@ -174,6 +190,7 @@ public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T
     public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> Each(Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.EachIterPointerCallbackDelegate).Build();
     }
 
@@ -184,6 +201,7 @@ public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T
     public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> Each(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, T14*, T15*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.EachPointerCallbackPointer).Build();
     }
 
@@ -194,6 +212,7 @@ public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T
     public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> Each(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, T14*, T15*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.EachEntityPointerCallbackPointer).Build();
     }
 
@@ -204,6 +223,7 @@ public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T
     public System<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> Each(delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, T14*, T15*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.EachIterPointerCallbackPointer).Build();
     }
 }
\ No newline at end of file
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/SystemBuilder/SystemBuilder.NodeBuilder/T2.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/SystemBuilder/SystemBuilder.NodeBuilder/T2.g.cs
index c4d7e7a0..188881f4 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/SystemBuilder/SystemBuilder.NodeBuilder/T2.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/SystemBuilder/SystemBuilder.NodeBuilder/T2.g.cs
@@ -14,6 +14,7 @@ public unsafe partial struct SystemBuilder<T0, T1>
     public System<T0, T1> Run(Ecs.RunCallback callback)
     {
         TypeHelper<T0, T1>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1>.AssertSparseTypes(World, true);
         return SetRun(callback, Pointers<T0, T1>.RunCallbackDelegate).Build();
     }
 
@@ -24,6 +25,7 @@ public System<T0, T1> Run(Ecs.RunCallback callback)
     public System<T0, T1> Run(delegate*<Iter, void> callback)
     {
         TypeHelper<T0, T1>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1>.AssertSparseTypes(World, true);
         return SetRun((IntPtr)callback, Pointers<T0, T1>.RunCallbackPointer).Build();
     }
 
@@ -34,6 +36,7 @@ public System<T0, T1> Run(delegate*<Iter, void> callback)
     public System<T0, T1> Iter(Ecs.IterFieldCallback<T0, T1> callback)
     {
         TypeHelper<T0, T1>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1>.AssertSparseTypes(World, false);
         return SetCallback(callback, Pointers<T0, T1>.IterFieldCallbackDelegate).Build();
     }
 
@@ -44,6 +47,7 @@ public System<T0, T1> Iter(Ecs.IterFieldCallback<T0, T1> callback)
     public System<T0, T1> Iter(Ecs.IterSpanCallback<T0, T1> callback)
     {
         TypeHelper<T0, T1>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1>.AssertSparseTypes(World, false);
         return SetCallback(callback, Pointers<T0, T1>.IterSpanCallbackDelegate).Build();
     }
 
@@ -54,6 +58,7 @@ public System<T0, T1> Iter(Ecs.IterSpanCallback<T0, T1> callback)
     public System<T0, T1> Iter(Ecs.IterPointerCallback<T0, T1> callback)
     {
         TypeHelper<T0, T1>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1>.AssertSparseTypes(World, false);
         return SetCallback(callback, Pointers<T0, T1>.IterPointerCallbackDelegate).Build();
     }
 
@@ -64,6 +69,7 @@ public System<T0, T1> Iter(Ecs.IterPointerCallback<T0, T1> callback)
     public System<T0, T1> Iter(delegate*<Iter, Field<T0>, Field<T1>, void> callback)
     {
         TypeHelper<T0, T1>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1>.AssertSparseTypes(World, false);
         return SetCallback((IntPtr)callback, Pointers<T0, T1>.IterFieldCallbackPointer).Build();
     }
 
@@ -74,6 +80,7 @@ public System<T0, T1> Iter(delegate*<Iter, Field<T0>, Field<T1>, void> callback)
     public System<T0, T1> Iter(delegate*<Iter, Span<T0>, Span<T1>, void> callback)
     {
         TypeHelper<T0, T1>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1>.AssertSparseTypes(World, false);
         return SetCallback((IntPtr)callback, Pointers<T0, T1>.IterSpanCallbackPointer).Build();
     }
 
@@ -84,6 +91,7 @@ public System<T0, T1> Iter(delegate*<Iter, Span<T0>, Span<T1>, void> callback)
     public System<T0, T1> Iter(delegate*<Iter, T0*, T1*, void> callback)
     {
         TypeHelper<T0, T1>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1>.AssertSparseTypes(World, false);
         return SetCallback((IntPtr)callback, Pointers<T0, T1>.IterPointerCallbackPointer).Build();
     }
 
@@ -94,6 +102,7 @@ public System<T0, T1> Iter(delegate*<Iter, T0*, T1*, void> callback)
     public System<T0, T1> Each(Ecs.EachRefCallback<T0, T1> callback)
     {
         TypeHelper<T0, T1>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0, T1>.EachRefCallbackDelegate).Build();
     }
 
@@ -104,6 +113,7 @@ public System<T0, T1> Each(Ecs.EachRefCallback<T0, T1> callback)
     public System<T0, T1> Each(Ecs.EachEntityRefCallback<T0, T1> callback)
     {
         TypeHelper<T0, T1>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0, T1>.EachEntityRefCallbackDelegate).Build();
     }
 
@@ -114,6 +124,7 @@ public System<T0, T1> Each(Ecs.EachEntityRefCallback<T0, T1> callback)
     public System<T0, T1> Each(Ecs.EachIterRefCallback<T0, T1> callback)
     {
         TypeHelper<T0, T1>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0, T1>.EachIterRefCallbackDelegate).Build();
     }
 
@@ -124,6 +135,7 @@ public System<T0, T1> Each(Ecs.EachIterRefCallback<T0, T1> callback)
     public System<T0, T1> Each(delegate*<ref T0, ref T1, void> callback)
     {
         TypeHelper<T0, T1>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0, T1>.EachRefCallbackPointer).Build();
     }
 
@@ -134,6 +146,7 @@ public System<T0, T1> Each(delegate*<ref T0, ref T1, void> callback)
     public System<T0, T1> Each(delegate*<Entity, ref T0, ref T1, void> callback)
     {
         TypeHelper<T0, T1>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0, T1>.EachEntityRefCallbackPointer).Build();
     }
 
@@ -144,6 +157,7 @@ public System<T0, T1> Each(delegate*<Entity, ref T0, ref T1, void> callback)
     public System<T0, T1> Each(delegate*<Iter, int, ref T0, ref T1, void> callback)
     {
         TypeHelper<T0, T1>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0, T1>.EachIterRefCallbackPointer).Build();
     }
 
@@ -154,6 +168,7 @@ public System<T0, T1> Each(delegate*<Iter, int, ref T0, ref T1, void> callback)
     public System<T0, T1> Each(Ecs.EachPointerCallback<T0, T1> callback)
     {
         TypeHelper<T0, T1>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0, T1>.EachPointerCallbackDelegate).Build();
     }
 
@@ -164,6 +179,7 @@ public System<T0, T1> Each(Ecs.EachPointerCallback<T0, T1> callback)
     public System<T0, T1> Each(Ecs.EachEntityPointerCallback<T0, T1> callback)
     {
         TypeHelper<T0, T1>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0, T1>.EachEntityPointerCallbackDelegate).Build();
     }
 
@@ -174,6 +190,7 @@ public System<T0, T1> Each(Ecs.EachEntityPointerCallback<T0, T1> callback)
     public System<T0, T1> Each(Ecs.EachIterPointerCallback<T0, T1> callback)
     {
         TypeHelper<T0, T1>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0, T1>.EachIterPointerCallbackDelegate).Build();
     }
 
@@ -184,6 +201,7 @@ public System<T0, T1> Each(Ecs.EachIterPointerCallback<T0, T1> callback)
     public System<T0, T1> Each(delegate*<T0*, T1*, void> callback)
     {
         TypeHelper<T0, T1>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0, T1>.EachPointerCallbackPointer).Build();
     }
 
@@ -194,6 +212,7 @@ public System<T0, T1> Each(delegate*<T0*, T1*, void> callback)
     public System<T0, T1> Each(delegate*<Entity, T0*, T1*, void> callback)
     {
         TypeHelper<T0, T1>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0, T1>.EachEntityPointerCallbackPointer).Build();
     }
 
@@ -204,6 +223,7 @@ public System<T0, T1> Each(delegate*<Entity, T0*, T1*, void> callback)
     public System<T0, T1> Each(delegate*<Iter, int, T0*, T1*, void> callback)
     {
         TypeHelper<T0, T1>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0, T1>.EachIterPointerCallbackPointer).Build();
     }
 }
\ No newline at end of file
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/SystemBuilder/SystemBuilder.NodeBuilder/T3.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/SystemBuilder/SystemBuilder.NodeBuilder/T3.g.cs
index 0369df7a..683a7c9e 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/SystemBuilder/SystemBuilder.NodeBuilder/T3.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/SystemBuilder/SystemBuilder.NodeBuilder/T3.g.cs
@@ -14,6 +14,7 @@ public unsafe partial struct SystemBuilder<T0, T1, T2>
     public System<T0, T1, T2> Run(Ecs.RunCallback callback)
     {
         TypeHelper<T0, T1, T2>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2>.AssertSparseTypes(World, true);
         return SetRun(callback, Pointers<T0, T1, T2>.RunCallbackDelegate).Build();
     }
 
@@ -24,6 +25,7 @@ public System<T0, T1, T2> Run(Ecs.RunCallback callback)
     public System<T0, T1, T2> Run(delegate*<Iter, void> callback)
     {
         TypeHelper<T0, T1, T2>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2>.AssertSparseTypes(World, true);
         return SetRun((IntPtr)callback, Pointers<T0, T1, T2>.RunCallbackPointer).Build();
     }
 
@@ -34,6 +36,7 @@ public System<T0, T1, T2> Run(delegate*<Iter, void> callback)
     public System<T0, T1, T2> Iter(Ecs.IterFieldCallback<T0, T1, T2> callback)
     {
         TypeHelper<T0, T1, T2>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2>.AssertSparseTypes(World, false);
         return SetCallback(callback, Pointers<T0, T1, T2>.IterFieldCallbackDelegate).Build();
     }
 
@@ -44,6 +47,7 @@ public System<T0, T1, T2> Iter(Ecs.IterFieldCallback<T0, T1, T2> callback)
     public System<T0, T1, T2> Iter(Ecs.IterSpanCallback<T0, T1, T2> callback)
     {
         TypeHelper<T0, T1, T2>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2>.AssertSparseTypes(World, false);
         return SetCallback(callback, Pointers<T0, T1, T2>.IterSpanCallbackDelegate).Build();
     }
 
@@ -54,6 +58,7 @@ public System<T0, T1, T2> Iter(Ecs.IterSpanCallback<T0, T1, T2> callback)
     public System<T0, T1, T2> Iter(Ecs.IterPointerCallback<T0, T1, T2> callback)
     {
         TypeHelper<T0, T1, T2>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2>.AssertSparseTypes(World, false);
         return SetCallback(callback, Pointers<T0, T1, T2>.IterPointerCallbackDelegate).Build();
     }
 
@@ -64,6 +69,7 @@ public System<T0, T1, T2> Iter(Ecs.IterPointerCallback<T0, T1, T2> callback)
     public System<T0, T1, T2> Iter(delegate*<Iter, Field<T0>, Field<T1>, Field<T2>, void> callback)
     {
         TypeHelper<T0, T1, T2>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2>.AssertSparseTypes(World, false);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2>.IterFieldCallbackPointer).Build();
     }
 
@@ -74,6 +80,7 @@ public System<T0, T1, T2> Iter(delegate*<Iter, Field<T0>, Field<T1>, Field<T2>,
     public System<T0, T1, T2> Iter(delegate*<Iter, Span<T0>, Span<T1>, Span<T2>, void> callback)
     {
         TypeHelper<T0, T1, T2>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2>.AssertSparseTypes(World, false);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2>.IterSpanCallbackPointer).Build();
     }
 
@@ -84,6 +91,7 @@ public System<T0, T1, T2> Iter(delegate*<Iter, Span<T0>, Span<T1>, Span<T2>, voi
     public System<T0, T1, T2> Iter(delegate*<Iter, T0*, T1*, T2*, void> callback)
     {
         TypeHelper<T0, T1, T2>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2>.AssertSparseTypes(World, false);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2>.IterPointerCallbackPointer).Build();
     }
 
@@ -94,6 +102,7 @@ public System<T0, T1, T2> Iter(delegate*<Iter, T0*, T1*, T2*, void> callback)
     public System<T0, T1, T2> Each(Ecs.EachRefCallback<T0, T1, T2> callback)
     {
         TypeHelper<T0, T1, T2>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0, T1, T2>.EachRefCallbackDelegate).Build();
     }
 
@@ -104,6 +113,7 @@ public System<T0, T1, T2> Each(Ecs.EachRefCallback<T0, T1, T2> callback)
     public System<T0, T1, T2> Each(Ecs.EachEntityRefCallback<T0, T1, T2> callback)
     {
         TypeHelper<T0, T1, T2>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0, T1, T2>.EachEntityRefCallbackDelegate).Build();
     }
 
@@ -114,6 +124,7 @@ public System<T0, T1, T2> Each(Ecs.EachEntityRefCallback<T0, T1, T2> callback)
     public System<T0, T1, T2> Each(Ecs.EachIterRefCallback<T0, T1, T2> callback)
     {
         TypeHelper<T0, T1, T2>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0, T1, T2>.EachIterRefCallbackDelegate).Build();
     }
 
@@ -124,6 +135,7 @@ public System<T0, T1, T2> Each(Ecs.EachIterRefCallback<T0, T1, T2> callback)
     public System<T0, T1, T2> Each(delegate*<ref T0, ref T1, ref T2, void> callback)
     {
         TypeHelper<T0, T1, T2>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2>.EachRefCallbackPointer).Build();
     }
 
@@ -134,6 +146,7 @@ public System<T0, T1, T2> Each(delegate*<ref T0, ref T1, ref T2, void> callback)
     public System<T0, T1, T2> Each(delegate*<Entity, ref T0, ref T1, ref T2, void> callback)
     {
         TypeHelper<T0, T1, T2>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2>.EachEntityRefCallbackPointer).Build();
     }
 
@@ -144,6 +157,7 @@ public System<T0, T1, T2> Each(delegate*<Entity, ref T0, ref T1, ref T2, void> c
     public System<T0, T1, T2> Each(delegate*<Iter, int, ref T0, ref T1, ref T2, void> callback)
     {
         TypeHelper<T0, T1, T2>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2>.EachIterRefCallbackPointer).Build();
     }
 
@@ -154,6 +168,7 @@ public System<T0, T1, T2> Each(delegate*<Iter, int, ref T0, ref T1, ref T2, void
     public System<T0, T1, T2> Each(Ecs.EachPointerCallback<T0, T1, T2> callback)
     {
         TypeHelper<T0, T1, T2>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0, T1, T2>.EachPointerCallbackDelegate).Build();
     }
 
@@ -164,6 +179,7 @@ public System<T0, T1, T2> Each(Ecs.EachPointerCallback<T0, T1, T2> callback)
     public System<T0, T1, T2> Each(Ecs.EachEntityPointerCallback<T0, T1, T2> callback)
     {
         TypeHelper<T0, T1, T2>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0, T1, T2>.EachEntityPointerCallbackDelegate).Build();
     }
 
@@ -174,6 +190,7 @@ public System<T0, T1, T2> Each(Ecs.EachEntityPointerCallback<T0, T1, T2> callbac
     public System<T0, T1, T2> Each(Ecs.EachIterPointerCallback<T0, T1, T2> callback)
     {
         TypeHelper<T0, T1, T2>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0, T1, T2>.EachIterPointerCallbackDelegate).Build();
     }
 
@@ -184,6 +201,7 @@ public System<T0, T1, T2> Each(Ecs.EachIterPointerCallback<T0, T1, T2> callback)
     public System<T0, T1, T2> Each(delegate*<T0*, T1*, T2*, void> callback)
     {
         TypeHelper<T0, T1, T2>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2>.EachPointerCallbackPointer).Build();
     }
 
@@ -194,6 +212,7 @@ public System<T0, T1, T2> Each(delegate*<T0*, T1*, T2*, void> callback)
     public System<T0, T1, T2> Each(delegate*<Entity, T0*, T1*, T2*, void> callback)
     {
         TypeHelper<T0, T1, T2>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2>.EachEntityPointerCallbackPointer).Build();
     }
 
@@ -204,6 +223,7 @@ public System<T0, T1, T2> Each(delegate*<Entity, T0*, T1*, T2*, void> callback)
     public System<T0, T1, T2> Each(delegate*<Iter, int, T0*, T1*, T2*, void> callback)
     {
         TypeHelper<T0, T1, T2>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2>.EachIterPointerCallbackPointer).Build();
     }
 }
\ No newline at end of file
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/SystemBuilder/SystemBuilder.NodeBuilder/T4.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/SystemBuilder/SystemBuilder.NodeBuilder/T4.g.cs
index 0201725c..b0228d13 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/SystemBuilder/SystemBuilder.NodeBuilder/T4.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/SystemBuilder/SystemBuilder.NodeBuilder/T4.g.cs
@@ -14,6 +14,7 @@ public unsafe partial struct SystemBuilder<T0, T1, T2, T3>
     public System<T0, T1, T2, T3> Run(Ecs.RunCallback callback)
     {
         TypeHelper<T0, T1, T2, T3>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3>.AssertSparseTypes(World, true);
         return SetRun(callback, Pointers<T0, T1, T2, T3>.RunCallbackDelegate).Build();
     }
 
@@ -24,6 +25,7 @@ public System<T0, T1, T2, T3> Run(Ecs.RunCallback callback)
     public System<T0, T1, T2, T3> Run(delegate*<Iter, void> callback)
     {
         TypeHelper<T0, T1, T2, T3>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3>.AssertSparseTypes(World, true);
         return SetRun((IntPtr)callback, Pointers<T0, T1, T2, T3>.RunCallbackPointer).Build();
     }
 
@@ -34,6 +36,7 @@ public System<T0, T1, T2, T3> Run(delegate*<Iter, void> callback)
     public System<T0, T1, T2, T3> Iter(Ecs.IterFieldCallback<T0, T1, T2, T3> callback)
     {
         TypeHelper<T0, T1, T2, T3>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3>.AssertSparseTypes(World, false);
         return SetCallback(callback, Pointers<T0, T1, T2, T3>.IterFieldCallbackDelegate).Build();
     }
 
@@ -44,6 +47,7 @@ public System<T0, T1, T2, T3> Iter(Ecs.IterFieldCallback<T0, T1, T2, T3> callbac
     public System<T0, T1, T2, T3> Iter(Ecs.IterSpanCallback<T0, T1, T2, T3> callback)
     {
         TypeHelper<T0, T1, T2, T3>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3>.AssertSparseTypes(World, false);
         return SetCallback(callback, Pointers<T0, T1, T2, T3>.IterSpanCallbackDelegate).Build();
     }
 
@@ -54,6 +58,7 @@ public System<T0, T1, T2, T3> Iter(Ecs.IterSpanCallback<T0, T1, T2, T3> callback
     public System<T0, T1, T2, T3> Iter(Ecs.IterPointerCallback<T0, T1, T2, T3> callback)
     {
         TypeHelper<T0, T1, T2, T3>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3>.AssertSparseTypes(World, false);
         return SetCallback(callback, Pointers<T0, T1, T2, T3>.IterPointerCallbackDelegate).Build();
     }
 
@@ -64,6 +69,7 @@ public System<T0, T1, T2, T3> Iter(Ecs.IterPointerCallback<T0, T1, T2, T3> callb
     public System<T0, T1, T2, T3> Iter(delegate*<Iter, Field<T0>, Field<T1>, Field<T2>, Field<T3>, void> callback)
     {
         TypeHelper<T0, T1, T2, T3>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3>.AssertSparseTypes(World, false);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3>.IterFieldCallbackPointer).Build();
     }
 
@@ -74,6 +80,7 @@ public System<T0, T1, T2, T3> Iter(delegate*<Iter, Field<T0>, Field<T1>, Field<T
     public System<T0, T1, T2, T3> Iter(delegate*<Iter, Span<T0>, Span<T1>, Span<T2>, Span<T3>, void> callback)
     {
         TypeHelper<T0, T1, T2, T3>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3>.AssertSparseTypes(World, false);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3>.IterSpanCallbackPointer).Build();
     }
 
@@ -84,6 +91,7 @@ public System<T0, T1, T2, T3> Iter(delegate*<Iter, Span<T0>, Span<T1>, Span<T2>,
     public System<T0, T1, T2, T3> Iter(delegate*<Iter, T0*, T1*, T2*, T3*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3>.AssertSparseTypes(World, false);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3>.IterPointerCallbackPointer).Build();
     }
 
@@ -94,6 +102,7 @@ public System<T0, T1, T2, T3> Iter(delegate*<Iter, T0*, T1*, T2*, T3*, void> cal
     public System<T0, T1, T2, T3> Each(Ecs.EachRefCallback<T0, T1, T2, T3> callback)
     {
         TypeHelper<T0, T1, T2, T3>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0, T1, T2, T3>.EachRefCallbackDelegate).Build();
     }
 
@@ -104,6 +113,7 @@ public System<T0, T1, T2, T3> Each(Ecs.EachRefCallback<T0, T1, T2, T3> callback)
     public System<T0, T1, T2, T3> Each(Ecs.EachEntityRefCallback<T0, T1, T2, T3> callback)
     {
         TypeHelper<T0, T1, T2, T3>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0, T1, T2, T3>.EachEntityRefCallbackDelegate).Build();
     }
 
@@ -114,6 +124,7 @@ public System<T0, T1, T2, T3> Each(Ecs.EachEntityRefCallback<T0, T1, T2, T3> cal
     public System<T0, T1, T2, T3> Each(Ecs.EachIterRefCallback<T0, T1, T2, T3> callback)
     {
         TypeHelper<T0, T1, T2, T3>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0, T1, T2, T3>.EachIterRefCallbackDelegate).Build();
     }
 
@@ -124,6 +135,7 @@ public System<T0, T1, T2, T3> Each(Ecs.EachIterRefCallback<T0, T1, T2, T3> callb
     public System<T0, T1, T2, T3> Each(delegate*<ref T0, ref T1, ref T2, ref T3, void> callback)
     {
         TypeHelper<T0, T1, T2, T3>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3>.EachRefCallbackPointer).Build();
     }
 
@@ -134,6 +146,7 @@ public System<T0, T1, T2, T3> Each(delegate*<ref T0, ref T1, ref T2, ref T3, voi
     public System<T0, T1, T2, T3> Each(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, void> callback)
     {
         TypeHelper<T0, T1, T2, T3>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3>.EachEntityRefCallbackPointer).Build();
     }
 
@@ -144,6 +157,7 @@ public System<T0, T1, T2, T3> Each(delegate*<Entity, ref T0, ref T1, ref T2, ref
     public System<T0, T1, T2, T3> Each(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, void> callback)
     {
         TypeHelper<T0, T1, T2, T3>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3>.EachIterRefCallbackPointer).Build();
     }
 
@@ -154,6 +168,7 @@ public System<T0, T1, T2, T3> Each(delegate*<Iter, int, ref T0, ref T1, ref T2,
     public System<T0, T1, T2, T3> Each(Ecs.EachPointerCallback<T0, T1, T2, T3> callback)
     {
         TypeHelper<T0, T1, T2, T3>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0, T1, T2, T3>.EachPointerCallbackDelegate).Build();
     }
 
@@ -164,6 +179,7 @@ public System<T0, T1, T2, T3> Each(Ecs.EachPointerCallback<T0, T1, T2, T3> callb
     public System<T0, T1, T2, T3> Each(Ecs.EachEntityPointerCallback<T0, T1, T2, T3> callback)
     {
         TypeHelper<T0, T1, T2, T3>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0, T1, T2, T3>.EachEntityPointerCallbackDelegate).Build();
     }
 
@@ -174,6 +190,7 @@ public System<T0, T1, T2, T3> Each(Ecs.EachEntityPointerCallback<T0, T1, T2, T3>
     public System<T0, T1, T2, T3> Each(Ecs.EachIterPointerCallback<T0, T1, T2, T3> callback)
     {
         TypeHelper<T0, T1, T2, T3>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0, T1, T2, T3>.EachIterPointerCallbackDelegate).Build();
     }
 
@@ -184,6 +201,7 @@ public System<T0, T1, T2, T3> Each(Ecs.EachIterPointerCallback<T0, T1, T2, T3> c
     public System<T0, T1, T2, T3> Each(delegate*<T0*, T1*, T2*, T3*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3>.EachPointerCallbackPointer).Build();
     }
 
@@ -194,6 +212,7 @@ public System<T0, T1, T2, T3> Each(delegate*<T0*, T1*, T2*, T3*, void> callback)
     public System<T0, T1, T2, T3> Each(delegate*<Entity, T0*, T1*, T2*, T3*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3>.EachEntityPointerCallbackPointer).Build();
     }
 
@@ -204,6 +223,7 @@ public System<T0, T1, T2, T3> Each(delegate*<Entity, T0*, T1*, T2*, T3*, void> c
     public System<T0, T1, T2, T3> Each(delegate*<Iter, int, T0*, T1*, T2*, T3*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3>.EachIterPointerCallbackPointer).Build();
     }
 }
\ No newline at end of file
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/SystemBuilder/SystemBuilder.NodeBuilder/T5.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/SystemBuilder/SystemBuilder.NodeBuilder/T5.g.cs
index d056d076..a0845164 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/SystemBuilder/SystemBuilder.NodeBuilder/T5.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/SystemBuilder/SystemBuilder.NodeBuilder/T5.g.cs
@@ -14,6 +14,7 @@ public unsafe partial struct SystemBuilder<T0, T1, T2, T3, T4>
     public System<T0, T1, T2, T3, T4> Run(Ecs.RunCallback callback)
     {
         TypeHelper<T0, T1, T2, T3, T4>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4>.AssertSparseTypes(World, true);
         return SetRun(callback, Pointers<T0, T1, T2, T3, T4>.RunCallbackDelegate).Build();
     }
 
@@ -24,6 +25,7 @@ public System<T0, T1, T2, T3, T4> Run(Ecs.RunCallback callback)
     public System<T0, T1, T2, T3, T4> Run(delegate*<Iter, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4>.AssertSparseTypes(World, true);
         return SetRun((IntPtr)callback, Pointers<T0, T1, T2, T3, T4>.RunCallbackPointer).Build();
     }
 
@@ -34,6 +36,7 @@ public System<T0, T1, T2, T3, T4> Run(delegate*<Iter, void> callback)
     public System<T0, T1, T2, T3, T4> Iter(Ecs.IterFieldCallback<T0, T1, T2, T3, T4> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4>.AssertSparseTypes(World, false);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4>.IterFieldCallbackDelegate).Build();
     }
 
@@ -44,6 +47,7 @@ public System<T0, T1, T2, T3, T4> Iter(Ecs.IterFieldCallback<T0, T1, T2, T3, T4>
     public System<T0, T1, T2, T3, T4> Iter(Ecs.IterSpanCallback<T0, T1, T2, T3, T4> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4>.AssertSparseTypes(World, false);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4>.IterSpanCallbackDelegate).Build();
     }
 
@@ -54,6 +58,7 @@ public System<T0, T1, T2, T3, T4> Iter(Ecs.IterSpanCallback<T0, T1, T2, T3, T4>
     public System<T0, T1, T2, T3, T4> Iter(Ecs.IterPointerCallback<T0, T1, T2, T3, T4> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4>.AssertSparseTypes(World, false);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4>.IterPointerCallbackDelegate).Build();
     }
 
@@ -64,6 +69,7 @@ public System<T0, T1, T2, T3, T4> Iter(Ecs.IterPointerCallback<T0, T1, T2, T3, T
     public System<T0, T1, T2, T3, T4> Iter(delegate*<Iter, Field<T0>, Field<T1>, Field<T2>, Field<T3>, Field<T4>, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4>.AssertSparseTypes(World, false);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4>.IterFieldCallbackPointer).Build();
     }
 
@@ -74,6 +80,7 @@ public System<T0, T1, T2, T3, T4> Iter(delegate*<Iter, Field<T0>, Field<T1>, Fie
     public System<T0, T1, T2, T3, T4> Iter(delegate*<Iter, Span<T0>, Span<T1>, Span<T2>, Span<T3>, Span<T4>, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4>.AssertSparseTypes(World, false);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4>.IterSpanCallbackPointer).Build();
     }
 
@@ -84,6 +91,7 @@ public System<T0, T1, T2, T3, T4> Iter(delegate*<Iter, Span<T0>, Span<T1>, Span<
     public System<T0, T1, T2, T3, T4> Iter(delegate*<Iter, T0*, T1*, T2*, T3*, T4*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4>.AssertSparseTypes(World, false);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4>.IterPointerCallbackPointer).Build();
     }
 
@@ -94,6 +102,7 @@ public System<T0, T1, T2, T3, T4> Iter(delegate*<Iter, T0*, T1*, T2*, T3*, T4*,
     public System<T0, T1, T2, T3, T4> Each(Ecs.EachRefCallback<T0, T1, T2, T3, T4> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4>.EachRefCallbackDelegate).Build();
     }
 
@@ -104,6 +113,7 @@ public System<T0, T1, T2, T3, T4> Each(Ecs.EachRefCallback<T0, T1, T2, T3, T4> c
     public System<T0, T1, T2, T3, T4> Each(Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4>.EachEntityRefCallbackDelegate).Build();
     }
 
@@ -114,6 +124,7 @@ public System<T0, T1, T2, T3, T4> Each(Ecs.EachEntityRefCallback<T0, T1, T2, T3,
     public System<T0, T1, T2, T3, T4> Each(Ecs.EachIterRefCallback<T0, T1, T2, T3, T4> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4>.EachIterRefCallbackDelegate).Build();
     }
 
@@ -124,6 +135,7 @@ public System<T0, T1, T2, T3, T4> Each(Ecs.EachIterRefCallback<T0, T1, T2, T3, T
     public System<T0, T1, T2, T3, T4> Each(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4>.EachRefCallbackPointer).Build();
     }
 
@@ -134,6 +146,7 @@ public System<T0, T1, T2, T3, T4> Each(delegate*<ref T0, ref T1, ref T2, ref T3,
     public System<T0, T1, T2, T3, T4> Each(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4>.EachEntityRefCallbackPointer).Build();
     }
 
@@ -144,6 +157,7 @@ public System<T0, T1, T2, T3, T4> Each(delegate*<Entity, ref T0, ref T1, ref T2,
     public System<T0, T1, T2, T3, T4> Each(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4>.EachIterRefCallbackPointer).Build();
     }
 
@@ -154,6 +168,7 @@ public System<T0, T1, T2, T3, T4> Each(delegate*<Iter, int, ref T0, ref T1, ref
     public System<T0, T1, T2, T3, T4> Each(Ecs.EachPointerCallback<T0, T1, T2, T3, T4> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4>.EachPointerCallbackDelegate).Build();
     }
 
@@ -164,6 +179,7 @@ public System<T0, T1, T2, T3, T4> Each(Ecs.EachPointerCallback<T0, T1, T2, T3, T
     public System<T0, T1, T2, T3, T4> Each(Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4>.EachEntityPointerCallbackDelegate).Build();
     }
 
@@ -174,6 +190,7 @@ public System<T0, T1, T2, T3, T4> Each(Ecs.EachEntityPointerCallback<T0, T1, T2,
     public System<T0, T1, T2, T3, T4> Each(Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4>.EachIterPointerCallbackDelegate).Build();
     }
 
@@ -184,6 +201,7 @@ public System<T0, T1, T2, T3, T4> Each(Ecs.EachIterPointerCallback<T0, T1, T2, T
     public System<T0, T1, T2, T3, T4> Each(delegate*<T0*, T1*, T2*, T3*, T4*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4>.EachPointerCallbackPointer).Build();
     }
 
@@ -194,6 +212,7 @@ public System<T0, T1, T2, T3, T4> Each(delegate*<T0*, T1*, T2*, T3*, T4*, void>
     public System<T0, T1, T2, T3, T4> Each(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4>.EachEntityPointerCallbackPointer).Build();
     }
 
@@ -204,6 +223,7 @@ public System<T0, T1, T2, T3, T4> Each(delegate*<Entity, T0*, T1*, T2*, T3*, T4*
     public System<T0, T1, T2, T3, T4> Each(delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4>.EachIterPointerCallbackPointer).Build();
     }
 }
\ No newline at end of file
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/SystemBuilder/SystemBuilder.NodeBuilder/T6.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/SystemBuilder/SystemBuilder.NodeBuilder/T6.g.cs
index 2da6f8f5..231d28d5 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/SystemBuilder/SystemBuilder.NodeBuilder/T6.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/SystemBuilder/SystemBuilder.NodeBuilder/T6.g.cs
@@ -14,6 +14,7 @@ public unsafe partial struct SystemBuilder<T0, T1, T2, T3, T4, T5>
     public System<T0, T1, T2, T3, T4, T5> Run(Ecs.RunCallback callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5>.AssertSparseTypes(World, true);
         return SetRun(callback, Pointers<T0, T1, T2, T3, T4, T5>.RunCallbackDelegate).Build();
     }
 
@@ -24,6 +25,7 @@ public System<T0, T1, T2, T3, T4, T5> Run(Ecs.RunCallback callback)
     public System<T0, T1, T2, T3, T4, T5> Run(delegate*<Iter, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5>.AssertSparseTypes(World, true);
         return SetRun((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5>.RunCallbackPointer).Build();
     }
 
@@ -34,6 +36,7 @@ public System<T0, T1, T2, T3, T4, T5> Run(delegate*<Iter, void> callback)
     public System<T0, T1, T2, T3, T4, T5> Iter(Ecs.IterFieldCallback<T0, T1, T2, T3, T4, T5> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5>.AssertSparseTypes(World, false);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5>.IterFieldCallbackDelegate).Build();
     }
 
@@ -44,6 +47,7 @@ public System<T0, T1, T2, T3, T4, T5> Iter(Ecs.IterFieldCallback<T0, T1, T2, T3,
     public System<T0, T1, T2, T3, T4, T5> Iter(Ecs.IterSpanCallback<T0, T1, T2, T3, T4, T5> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5>.AssertSparseTypes(World, false);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5>.IterSpanCallbackDelegate).Build();
     }
 
@@ -54,6 +58,7 @@ public System<T0, T1, T2, T3, T4, T5> Iter(Ecs.IterSpanCallback<T0, T1, T2, T3,
     public System<T0, T1, T2, T3, T4, T5> Iter(Ecs.IterPointerCallback<T0, T1, T2, T3, T4, T5> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5>.AssertSparseTypes(World, false);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5>.IterPointerCallbackDelegate).Build();
     }
 
@@ -64,6 +69,7 @@ public System<T0, T1, T2, T3, T4, T5> Iter(Ecs.IterPointerCallback<T0, T1, T2, T
     public System<T0, T1, T2, T3, T4, T5> Iter(delegate*<Iter, Field<T0>, Field<T1>, Field<T2>, Field<T3>, Field<T4>, Field<T5>, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5>.AssertSparseTypes(World, false);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5>.IterFieldCallbackPointer).Build();
     }
 
@@ -74,6 +80,7 @@ public System<T0, T1, T2, T3, T4, T5> Iter(delegate*<Iter, Field<T0>, Field<T1>,
     public System<T0, T1, T2, T3, T4, T5> Iter(delegate*<Iter, Span<T0>, Span<T1>, Span<T2>, Span<T3>, Span<T4>, Span<T5>, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5>.AssertSparseTypes(World, false);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5>.IterSpanCallbackPointer).Build();
     }
 
@@ -84,6 +91,7 @@ public System<T0, T1, T2, T3, T4, T5> Iter(delegate*<Iter, Span<T0>, Span<T1>, S
     public System<T0, T1, T2, T3, T4, T5> Iter(delegate*<Iter, T0*, T1*, T2*, T3*, T4*, T5*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5>.AssertSparseTypes(World, false);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5>.IterPointerCallbackPointer).Build();
     }
 
@@ -94,6 +102,7 @@ public System<T0, T1, T2, T3, T4, T5> Iter(delegate*<Iter, T0*, T1*, T2*, T3*, T
     public System<T0, T1, T2, T3, T4, T5> Each(Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5>.EachRefCallbackDelegate).Build();
     }
 
@@ -104,6 +113,7 @@ public System<T0, T1, T2, T3, T4, T5> Each(Ecs.EachRefCallback<T0, T1, T2, T3, T
     public System<T0, T1, T2, T3, T4, T5> Each(Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5>.EachEntityRefCallbackDelegate).Build();
     }
 
@@ -114,6 +124,7 @@ public System<T0, T1, T2, T3, T4, T5> Each(Ecs.EachEntityRefCallback<T0, T1, T2,
     public System<T0, T1, T2, T3, T4, T5> Each(Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5>.EachIterRefCallbackDelegate).Build();
     }
 
@@ -124,6 +135,7 @@ public System<T0, T1, T2, T3, T4, T5> Each(Ecs.EachIterRefCallback<T0, T1, T2, T
     public System<T0, T1, T2, T3, T4, T5> Each(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5>.EachRefCallbackPointer).Build();
     }
 
@@ -134,6 +146,7 @@ public System<T0, T1, T2, T3, T4, T5> Each(delegate*<ref T0, ref T1, ref T2, ref
     public System<T0, T1, T2, T3, T4, T5> Each(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5>.EachEntityRefCallbackPointer).Build();
     }
 
@@ -144,6 +157,7 @@ public System<T0, T1, T2, T3, T4, T5> Each(delegate*<Entity, ref T0, ref T1, ref
     public System<T0, T1, T2, T3, T4, T5> Each(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5>.EachIterRefCallbackPointer).Build();
     }
 
@@ -154,6 +168,7 @@ public System<T0, T1, T2, T3, T4, T5> Each(delegate*<Iter, int, ref T0, ref T1,
     public System<T0, T1, T2, T3, T4, T5> Each(Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5>.EachPointerCallbackDelegate).Build();
     }
 
@@ -164,6 +179,7 @@ public System<T0, T1, T2, T3, T4, T5> Each(Ecs.EachPointerCallback<T0, T1, T2, T
     public System<T0, T1, T2, T3, T4, T5> Each(Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5>.EachEntityPointerCallbackDelegate).Build();
     }
 
@@ -174,6 +190,7 @@ public System<T0, T1, T2, T3, T4, T5> Each(Ecs.EachEntityPointerCallback<T0, T1,
     public System<T0, T1, T2, T3, T4, T5> Each(Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5>.EachIterPointerCallbackDelegate).Build();
     }
 
@@ -184,6 +201,7 @@ public System<T0, T1, T2, T3, T4, T5> Each(Ecs.EachIterPointerCallback<T0, T1, T
     public System<T0, T1, T2, T3, T4, T5> Each(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5>.EachPointerCallbackPointer).Build();
     }
 
@@ -194,6 +212,7 @@ public System<T0, T1, T2, T3, T4, T5> Each(delegate*<T0*, T1*, T2*, T3*, T4*, T5
     public System<T0, T1, T2, T3, T4, T5> Each(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5>.EachEntityPointerCallbackPointer).Build();
     }
 
@@ -204,6 +223,7 @@ public System<T0, T1, T2, T3, T4, T5> Each(delegate*<Entity, T0*, T1*, T2*, T3*,
     public System<T0, T1, T2, T3, T4, T5> Each(delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5>.EachIterPointerCallbackPointer).Build();
     }
 }
\ No newline at end of file
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/SystemBuilder/SystemBuilder.NodeBuilder/T7.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/SystemBuilder/SystemBuilder.NodeBuilder/T7.g.cs
index 95f673fc..f98ba009 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/SystemBuilder/SystemBuilder.NodeBuilder/T7.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/SystemBuilder/SystemBuilder.NodeBuilder/T7.g.cs
@@ -14,6 +14,7 @@ public unsafe partial struct SystemBuilder<T0, T1, T2, T3, T4, T5, T6>
     public System<T0, T1, T2, T3, T4, T5, T6> Run(Ecs.RunCallback callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertSparseTypes(World, true);
         return SetRun(callback, Pointers<T0, T1, T2, T3, T4, T5, T6>.RunCallbackDelegate).Build();
     }
 
@@ -24,6 +25,7 @@ public System<T0, T1, T2, T3, T4, T5, T6> Run(Ecs.RunCallback callback)
     public System<T0, T1, T2, T3, T4, T5, T6> Run(delegate*<Iter, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertSparseTypes(World, true);
         return SetRun((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6>.RunCallbackPointer).Build();
     }
 
@@ -34,6 +36,7 @@ public System<T0, T1, T2, T3, T4, T5, T6> Run(delegate*<Iter, void> callback)
     public System<T0, T1, T2, T3, T4, T5, T6> Iter(Ecs.IterFieldCallback<T0, T1, T2, T3, T4, T5, T6> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertSparseTypes(World, false);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5, T6>.IterFieldCallbackDelegate).Build();
     }
 
@@ -44,6 +47,7 @@ public System<T0, T1, T2, T3, T4, T5, T6> Iter(Ecs.IterFieldCallback<T0, T1, T2,
     public System<T0, T1, T2, T3, T4, T5, T6> Iter(Ecs.IterSpanCallback<T0, T1, T2, T3, T4, T5, T6> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertSparseTypes(World, false);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5, T6>.IterSpanCallbackDelegate).Build();
     }
 
@@ -54,6 +58,7 @@ public System<T0, T1, T2, T3, T4, T5, T6> Iter(Ecs.IterSpanCallback<T0, T1, T2,
     public System<T0, T1, T2, T3, T4, T5, T6> Iter(Ecs.IterPointerCallback<T0, T1, T2, T3, T4, T5, T6> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertSparseTypes(World, false);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5, T6>.IterPointerCallbackDelegate).Build();
     }
 
@@ -64,6 +69,7 @@ public System<T0, T1, T2, T3, T4, T5, T6> Iter(Ecs.IterPointerCallback<T0, T1, T
     public System<T0, T1, T2, T3, T4, T5, T6> Iter(delegate*<Iter, Field<T0>, Field<T1>, Field<T2>, Field<T3>, Field<T4>, Field<T5>, Field<T6>, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertSparseTypes(World, false);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6>.IterFieldCallbackPointer).Build();
     }
 
@@ -74,6 +80,7 @@ public System<T0, T1, T2, T3, T4, T5, T6> Iter(delegate*<Iter, Field<T0>, Field<
     public System<T0, T1, T2, T3, T4, T5, T6> Iter(delegate*<Iter, Span<T0>, Span<T1>, Span<T2>, Span<T3>, Span<T4>, Span<T5>, Span<T6>, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertSparseTypes(World, false);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6>.IterSpanCallbackPointer).Build();
     }
 
@@ -84,6 +91,7 @@ public System<T0, T1, T2, T3, T4, T5, T6> Iter(delegate*<Iter, Span<T0>, Span<T1
     public System<T0, T1, T2, T3, T4, T5, T6> Iter(delegate*<Iter, T0*, T1*, T2*, T3*, T4*, T5*, T6*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertSparseTypes(World, false);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6>.IterPointerCallbackPointer).Build();
     }
 
@@ -94,6 +102,7 @@ public System<T0, T1, T2, T3, T4, T5, T6> Iter(delegate*<Iter, T0*, T1*, T2*, T3
     public System<T0, T1, T2, T3, T4, T5, T6> Each(Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5, T6> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5, T6>.EachRefCallbackDelegate).Build();
     }
 
@@ -104,6 +113,7 @@ public System<T0, T1, T2, T3, T4, T5, T6> Each(Ecs.EachRefCallback<T0, T1, T2, T
     public System<T0, T1, T2, T3, T4, T5, T6> Each(Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5, T6> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5, T6>.EachEntityRefCallbackDelegate).Build();
     }
 
@@ -114,6 +124,7 @@ public System<T0, T1, T2, T3, T4, T5, T6> Each(Ecs.EachEntityRefCallback<T0, T1,
     public System<T0, T1, T2, T3, T4, T5, T6> Each(Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5, T6> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5, T6>.EachIterRefCallbackDelegate).Build();
     }
 
@@ -124,6 +135,7 @@ public System<T0, T1, T2, T3, T4, T5, T6> Each(Ecs.EachIterRefCallback<T0, T1, T
     public System<T0, T1, T2, T3, T4, T5, T6> Each(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6>.EachRefCallbackPointer).Build();
     }
 
@@ -134,6 +146,7 @@ public System<T0, T1, T2, T3, T4, T5, T6> Each(delegate*<ref T0, ref T1, ref T2,
     public System<T0, T1, T2, T3, T4, T5, T6> Each(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6>.EachEntityRefCallbackPointer).Build();
     }
 
@@ -144,6 +157,7 @@ public System<T0, T1, T2, T3, T4, T5, T6> Each(delegate*<Entity, ref T0, ref T1,
     public System<T0, T1, T2, T3, T4, T5, T6> Each(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6>.EachIterRefCallbackPointer).Build();
     }
 
@@ -154,6 +168,7 @@ public System<T0, T1, T2, T3, T4, T5, T6> Each(delegate*<Iter, int, ref T0, ref
     public System<T0, T1, T2, T3, T4, T5, T6> Each(Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5, T6> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5, T6>.EachPointerCallbackDelegate).Build();
     }
 
@@ -164,6 +179,7 @@ public System<T0, T1, T2, T3, T4, T5, T6> Each(Ecs.EachPointerCallback<T0, T1, T
     public System<T0, T1, T2, T3, T4, T5, T6> Each(Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5, T6>.EachEntityPointerCallbackDelegate).Build();
     }
 
@@ -174,6 +190,7 @@ public System<T0, T1, T2, T3, T4, T5, T6> Each(Ecs.EachEntityPointerCallback<T0,
     public System<T0, T1, T2, T3, T4, T5, T6> Each(Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5, T6> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5, T6>.EachIterPointerCallbackDelegate).Build();
     }
 
@@ -184,6 +201,7 @@ public System<T0, T1, T2, T3, T4, T5, T6> Each(Ecs.EachIterPointerCallback<T0, T
     public System<T0, T1, T2, T3, T4, T5, T6> Each(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6>.EachPointerCallbackPointer).Build();
     }
 
@@ -194,6 +212,7 @@ public System<T0, T1, T2, T3, T4, T5, T6> Each(delegate*<T0*, T1*, T2*, T3*, T4*
     public System<T0, T1, T2, T3, T4, T5, T6> Each(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6>.EachEntityPointerCallbackPointer).Build();
     }
 
@@ -204,6 +223,7 @@ public System<T0, T1, T2, T3, T4, T5, T6> Each(delegate*<Entity, T0*, T1*, T2*,
     public System<T0, T1, T2, T3, T4, T5, T6> Each(delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6>.EachIterPointerCallbackPointer).Build();
     }
 }
\ No newline at end of file
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/SystemBuilder/SystemBuilder.NodeBuilder/T8.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/SystemBuilder/SystemBuilder.NodeBuilder/T8.g.cs
index b9a6c7b0..b9da45c5 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/SystemBuilder/SystemBuilder.NodeBuilder/T8.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/SystemBuilder/SystemBuilder.NodeBuilder/T8.g.cs
@@ -14,6 +14,7 @@ public unsafe partial struct SystemBuilder<T0, T1, T2, T3, T4, T5, T6, T7>
     public System<T0, T1, T2, T3, T4, T5, T6, T7> Run(Ecs.RunCallback callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertSparseTypes(World, true);
         return SetRun(callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7>.RunCallbackDelegate).Build();
     }
 
@@ -24,6 +25,7 @@ public System<T0, T1, T2, T3, T4, T5, T6, T7> Run(Ecs.RunCallback callback)
     public System<T0, T1, T2, T3, T4, T5, T6, T7> Run(delegate*<Iter, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertSparseTypes(World, true);
         return SetRun((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7>.RunCallbackPointer).Build();
     }
 
@@ -34,6 +36,7 @@ public System<T0, T1, T2, T3, T4, T5, T6, T7> Run(delegate*<Iter, void> callback
     public System<T0, T1, T2, T3, T4, T5, T6, T7> Iter(Ecs.IterFieldCallback<T0, T1, T2, T3, T4, T5, T6, T7> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertSparseTypes(World, false);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7>.IterFieldCallbackDelegate).Build();
     }
 
@@ -44,6 +47,7 @@ public System<T0, T1, T2, T3, T4, T5, T6, T7> Iter(Ecs.IterFieldCallback<T0, T1,
     public System<T0, T1, T2, T3, T4, T5, T6, T7> Iter(Ecs.IterSpanCallback<T0, T1, T2, T3, T4, T5, T6, T7> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertSparseTypes(World, false);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7>.IterSpanCallbackDelegate).Build();
     }
 
@@ -54,6 +58,7 @@ public System<T0, T1, T2, T3, T4, T5, T6, T7> Iter(Ecs.IterSpanCallback<T0, T1,
     public System<T0, T1, T2, T3, T4, T5, T6, T7> Iter(Ecs.IterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertSparseTypes(World, false);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7>.IterPointerCallbackDelegate).Build();
     }
 
@@ -64,6 +69,7 @@ public System<T0, T1, T2, T3, T4, T5, T6, T7> Iter(Ecs.IterPointerCallback<T0, T
     public System<T0, T1, T2, T3, T4, T5, T6, T7> Iter(delegate*<Iter, Field<T0>, Field<T1>, Field<T2>, Field<T3>, Field<T4>, Field<T5>, Field<T6>, Field<T7>, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertSparseTypes(World, false);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7>.IterFieldCallbackPointer).Build();
     }
 
@@ -74,6 +80,7 @@ public System<T0, T1, T2, T3, T4, T5, T6, T7> Iter(delegate*<Iter, Field<T0>, Fi
     public System<T0, T1, T2, T3, T4, T5, T6, T7> Iter(delegate*<Iter, Span<T0>, Span<T1>, Span<T2>, Span<T3>, Span<T4>, Span<T5>, Span<T6>, Span<T7>, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertSparseTypes(World, false);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7>.IterSpanCallbackPointer).Build();
     }
 
@@ -84,6 +91,7 @@ public System<T0, T1, T2, T3, T4, T5, T6, T7> Iter(delegate*<Iter, Span<T0>, Spa
     public System<T0, T1, T2, T3, T4, T5, T6, T7> Iter(delegate*<Iter, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertSparseTypes(World, false);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7>.IterPointerCallbackPointer).Build();
     }
 
@@ -94,6 +102,7 @@ public System<T0, T1, T2, T3, T4, T5, T6, T7> Iter(delegate*<Iter, T0*, T1*, T2*
     public System<T0, T1, T2, T3, T4, T5, T6, T7> Each(Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5, T6, T7> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7>.EachRefCallbackDelegate).Build();
     }
 
@@ -104,6 +113,7 @@ public System<T0, T1, T2, T3, T4, T5, T6, T7> Each(Ecs.EachRefCallback<T0, T1, T
     public System<T0, T1, T2, T3, T4, T5, T6, T7> Each(Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7>.EachEntityRefCallbackDelegate).Build();
     }
 
@@ -114,6 +124,7 @@ public System<T0, T1, T2, T3, T4, T5, T6, T7> Each(Ecs.EachEntityRefCallback<T0,
     public System<T0, T1, T2, T3, T4, T5, T6, T7> Each(Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7>.EachIterRefCallbackDelegate).Build();
     }
 
@@ -124,6 +135,7 @@ public System<T0, T1, T2, T3, T4, T5, T6, T7> Each(Ecs.EachIterRefCallback<T0, T
     public System<T0, T1, T2, T3, T4, T5, T6, T7> Each(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7>.EachRefCallbackPointer).Build();
     }
 
@@ -134,6 +146,7 @@ public System<T0, T1, T2, T3, T4, T5, T6, T7> Each(delegate*<ref T0, ref T1, ref
     public System<T0, T1, T2, T3, T4, T5, T6, T7> Each(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7>.EachEntityRefCallbackPointer).Build();
     }
 
@@ -144,6 +157,7 @@ public System<T0, T1, T2, T3, T4, T5, T6, T7> Each(delegate*<Entity, ref T0, ref
     public System<T0, T1, T2, T3, T4, T5, T6, T7> Each(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7>.EachIterRefCallbackPointer).Build();
     }
 
@@ -154,6 +168,7 @@ public System<T0, T1, T2, T3, T4, T5, T6, T7> Each(delegate*<Iter, int, ref T0,
     public System<T0, T1, T2, T3, T4, T5, T6, T7> Each(Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7>.EachPointerCallbackDelegate).Build();
     }
 
@@ -164,6 +179,7 @@ public System<T0, T1, T2, T3, T4, T5, T6, T7> Each(Ecs.EachPointerCallback<T0, T
     public System<T0, T1, T2, T3, T4, T5, T6, T7> Each(Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7>.EachEntityPointerCallbackDelegate).Build();
     }
 
@@ -174,6 +190,7 @@ public System<T0, T1, T2, T3, T4, T5, T6, T7> Each(Ecs.EachEntityPointerCallback
     public System<T0, T1, T2, T3, T4, T5, T6, T7> Each(Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7>.EachIterPointerCallbackDelegate).Build();
     }
 
@@ -184,6 +201,7 @@ public System<T0, T1, T2, T3, T4, T5, T6, T7> Each(Ecs.EachIterPointerCallback<T
     public System<T0, T1, T2, T3, T4, T5, T6, T7> Each(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7>.EachPointerCallbackPointer).Build();
     }
 
@@ -194,6 +212,7 @@ public System<T0, T1, T2, T3, T4, T5, T6, T7> Each(delegate*<T0*, T1*, T2*, T3*,
     public System<T0, T1, T2, T3, T4, T5, T6, T7> Each(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7>.EachEntityPointerCallbackPointer).Build();
     }
 
@@ -204,6 +223,7 @@ public System<T0, T1, T2, T3, T4, T5, T6, T7> Each(delegate*<Entity, T0*, T1*, T
     public System<T0, T1, T2, T3, T4, T5, T6, T7> Each(delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7>.EachIterPointerCallbackPointer).Build();
     }
 }
\ No newline at end of file
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/SystemBuilder/SystemBuilder.NodeBuilder/T9.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/SystemBuilder/SystemBuilder.NodeBuilder/T9.g.cs
index 24823ed9..767947d7 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/SystemBuilder/SystemBuilder.NodeBuilder/T9.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/SystemBuilder/SystemBuilder.NodeBuilder/T9.g.cs
@@ -14,6 +14,7 @@ public unsafe partial struct SystemBuilder<T0, T1, T2, T3, T4, T5, T6, T7, T8>
     public System<T0, T1, T2, T3, T4, T5, T6, T7, T8> Run(Ecs.RunCallback callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertSparseTypes(World, true);
         return SetRun(callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8>.RunCallbackDelegate).Build();
     }
 
@@ -24,6 +25,7 @@ public System<T0, T1, T2, T3, T4, T5, T6, T7, T8> Run(Ecs.RunCallback callback)
     public System<T0, T1, T2, T3, T4, T5, T6, T7, T8> Run(delegate*<Iter, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertSparseTypes(World, true);
         return SetRun((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8>.RunCallbackPointer).Build();
     }
 
@@ -34,6 +36,7 @@ public System<T0, T1, T2, T3, T4, T5, T6, T7, T8> Run(delegate*<Iter, void> call
     public System<T0, T1, T2, T3, T4, T5, T6, T7, T8> Iter(Ecs.IterFieldCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertSparseTypes(World, false);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8>.IterFieldCallbackDelegate).Build();
     }
 
@@ -44,6 +47,7 @@ public System<T0, T1, T2, T3, T4, T5, T6, T7, T8> Iter(Ecs.IterFieldCallback<T0,
     public System<T0, T1, T2, T3, T4, T5, T6, T7, T8> Iter(Ecs.IterSpanCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertSparseTypes(World, false);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8>.IterSpanCallbackDelegate).Build();
     }
 
@@ -54,6 +58,7 @@ public System<T0, T1, T2, T3, T4, T5, T6, T7, T8> Iter(Ecs.IterSpanCallback<T0,
     public System<T0, T1, T2, T3, T4, T5, T6, T7, T8> Iter(Ecs.IterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertSparseTypes(World, false);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8>.IterPointerCallbackDelegate).Build();
     }
 
@@ -64,6 +69,7 @@ public System<T0, T1, T2, T3, T4, T5, T6, T7, T8> Iter(Ecs.IterPointerCallback<T
     public System<T0, T1, T2, T3, T4, T5, T6, T7, T8> Iter(delegate*<Iter, Field<T0>, Field<T1>, Field<T2>, Field<T3>, Field<T4>, Field<T5>, Field<T6>, Field<T7>, Field<T8>, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertSparseTypes(World, false);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8>.IterFieldCallbackPointer).Build();
     }
 
@@ -74,6 +80,7 @@ public System<T0, T1, T2, T3, T4, T5, T6, T7, T8> Iter(delegate*<Iter, Field<T0>
     public System<T0, T1, T2, T3, T4, T5, T6, T7, T8> Iter(delegate*<Iter, Span<T0>, Span<T1>, Span<T2>, Span<T3>, Span<T4>, Span<T5>, Span<T6>, Span<T7>, Span<T8>, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertSparseTypes(World, false);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8>.IterSpanCallbackPointer).Build();
     }
 
@@ -84,6 +91,7 @@ public System<T0, T1, T2, T3, T4, T5, T6, T7, T8> Iter(delegate*<Iter, Span<T0>,
     public System<T0, T1, T2, T3, T4, T5, T6, T7, T8> Iter(delegate*<Iter, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertSparseTypes(World, false);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8>.IterPointerCallbackPointer).Build();
     }
 
@@ -94,6 +102,7 @@ public System<T0, T1, T2, T3, T4, T5, T6, T7, T8> Iter(delegate*<Iter, T0*, T1*,
     public System<T0, T1, T2, T3, T4, T5, T6, T7, T8> Each(Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8>.EachRefCallbackDelegate).Build();
     }
 
@@ -104,6 +113,7 @@ public System<T0, T1, T2, T3, T4, T5, T6, T7, T8> Each(Ecs.EachRefCallback<T0, T
     public System<T0, T1, T2, T3, T4, T5, T6, T7, T8> Each(Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8>.EachEntityRefCallbackDelegate).Build();
     }
 
@@ -114,6 +124,7 @@ public System<T0, T1, T2, T3, T4, T5, T6, T7, T8> Each(Ecs.EachEntityRefCallback
     public System<T0, T1, T2, T3, T4, T5, T6, T7, T8> Each(Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8>.EachIterRefCallbackDelegate).Build();
     }
 
@@ -124,6 +135,7 @@ public System<T0, T1, T2, T3, T4, T5, T6, T7, T8> Each(Ecs.EachIterRefCallback<T
     public System<T0, T1, T2, T3, T4, T5, T6, T7, T8> Each(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8>.EachRefCallbackPointer).Build();
     }
 
@@ -134,6 +146,7 @@ public System<T0, T1, T2, T3, T4, T5, T6, T7, T8> Each(delegate*<ref T0, ref T1,
     public System<T0, T1, T2, T3, T4, T5, T6, T7, T8> Each(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8>.EachEntityRefCallbackPointer).Build();
     }
 
@@ -144,6 +157,7 @@ public System<T0, T1, T2, T3, T4, T5, T6, T7, T8> Each(delegate*<Entity, ref T0,
     public System<T0, T1, T2, T3, T4, T5, T6, T7, T8> Each(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8>.EachIterRefCallbackPointer).Build();
     }
 
@@ -154,6 +168,7 @@ public System<T0, T1, T2, T3, T4, T5, T6, T7, T8> Each(delegate*<Iter, int, ref
     public System<T0, T1, T2, T3, T4, T5, T6, T7, T8> Each(Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8>.EachPointerCallbackDelegate).Build();
     }
 
@@ -164,6 +179,7 @@ public System<T0, T1, T2, T3, T4, T5, T6, T7, T8> Each(Ecs.EachPointerCallback<T
     public System<T0, T1, T2, T3, T4, T5, T6, T7, T8> Each(Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8>.EachEntityPointerCallbackDelegate).Build();
     }
 
@@ -174,6 +190,7 @@ public System<T0, T1, T2, T3, T4, T5, T6, T7, T8> Each(Ecs.EachEntityPointerCall
     public System<T0, T1, T2, T3, T4, T5, T6, T7, T8> Each(Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertSparseTypes(World, true);
         return SetCallback(callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8>.EachIterPointerCallbackDelegate).Build();
     }
 
@@ -184,6 +201,7 @@ public System<T0, T1, T2, T3, T4, T5, T6, T7, T8> Each(Ecs.EachIterPointerCallba
     public System<T0, T1, T2, T3, T4, T5, T6, T7, T8> Each(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8>.EachPointerCallbackPointer).Build();
     }
 
@@ -194,6 +212,7 @@ public System<T0, T1, T2, T3, T4, T5, T6, T7, T8> Each(delegate*<T0*, T1*, T2*,
     public System<T0, T1, T2, T3, T4, T5, T6, T7, T8> Each(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8>.EachEntityPointerCallbackPointer).Build();
     }
 
@@ -204,6 +223,7 @@ public System<T0, T1, T2, T3, T4, T5, T6, T7, T8> Each(delegate*<Entity, T0*, T1
     public System<T0, T1, T2, T3, T4, T5, T6, T7, T8> Each(delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertSparseTypes(World, true);
         return SetCallback((IntPtr)callback, Pointers<T0, T1, T2, T3, T4, T5, T6, T7, T8>.EachIterPointerCallbackPointer).Build();
     }
 }
\ No newline at end of file
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/TypeHelper/T0.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/TypeHelper/T0.g.cs
index c0d9dd50..da9218c6 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/TypeHelper/T0.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/TypeHelper/T0.g.cs
@@ -6,11 +6,14 @@
 using System.Diagnostics.CodeAnalysis;
 using System.Linq;
 using System.Runtime.CompilerServices;
+using Flecs.NET.Utilities;
+
+using static Flecs.NET.Bindings.flecs;
 
 namespace Flecs.NET.Core;
 
 [SuppressMessage("ReSharper", "StaticMemberInGenericType")]
-internal static partial class TypeHelper<T0>
+internal static unsafe partial class TypeHelper<T0>
 {
     private static string[]? _typeNames;
     public static string[] TypeNames => _typeNames ??= [ Type<T0>.FullName ];
@@ -18,17 +21,20 @@ internal static partial class TypeHelper<T0>
     public static readonly int Tags = (Type<T0>.IsTag ? 1 << 0 : 0);
     public static readonly int ReferenceTypes = (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() ? 1 << 0 : 0);
     
+    private static string GetTypeListString(int fields)
+    {
+        return string.Join(", ", Enumerable.Range(0, 1)
+            .Where(i => (fields & (1 << i)) != 0)
+            .Select(i => TypeNames[i]));
+    }
+    
     [Conditional("DEBUG")]
     public static void AssertNoTags()
     {
         if (Tags == 0)
             return;
     
-        string tags = string.Join(", ", Enumerable.Range(0, 1)
-            .Where(i => (Tags & (1 << i)) != 0)
-            .Select(i => TypeNames[i]));
-    
-        Ecs.Error($"Cannot use zero-sized structs as generic type arguments for this struct. Remove the following type arguments: {tags}");
+        Ecs.Error($"Cannot use zero-sized structs as generic type arguments for this struct. Remove the following type arguments: {GetTypeListString(Tags)}");
     }
     
     [Conditional("DEBUG")]
@@ -37,10 +43,20 @@ public static void AssertReferenceTypes(bool allowReferenceTypes)
         if (allowReferenceTypes || ReferenceTypes == 0)
             return;
     
-        string referenceTypes = string.Join(", ", Enumerable.Range(0, 1)
-            .Where(i => (ReferenceTypes & (1 << i)) != 0)
-            .Select(i => TypeNames[i]));
+        Ecs.Error($"Cannot use managed types as generic type arguments for callback signatures that retrieve pointers or spans. Remove the following type arguments: {GetTypeListString(ReferenceTypes)}");
+    }
     
-        Ecs.Error($"Cannot use managed types as generic type arguments for callback signatures that retrieve pointers or spans. Remove the following type arguments: {referenceTypes}");
+    [Conditional("DEBUG")]
+    public static void AssertSparseTypes(ecs_world_t* world, bool allowSparseTypes)
+    {
+        if (allowSparseTypes)
+            return;
+ 
+        int sparseTypes = (ecs_has_id(world, Type<T0>.Id(world), Ecs.Sparse) == Utils.True ? 1 << 0 : 0);
+ 
+        if (sparseTypes == 0)
+            return;
+ 
+        Ecs.Error($"Cannot use sparse components as generic type arguments for this struct when using .Iter() to iterate because sparse fields must be obtained with Iter.FieldAt(). Use .Each()/.Run() to iterate or remove the following types from the list: {GetTypeListString(sparseTypes)}");
     }
 }
\ No newline at end of file
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/TypeHelper/T1.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/TypeHelper/T1.g.cs
index edadef01..51df41fd 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/TypeHelper/T1.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/TypeHelper/T1.g.cs
@@ -6,11 +6,14 @@
 using System.Diagnostics.CodeAnalysis;
 using System.Linq;
 using System.Runtime.CompilerServices;
+using Flecs.NET.Utilities;
+
+using static Flecs.NET.Bindings.flecs;
 
 namespace Flecs.NET.Core;
 
 [SuppressMessage("ReSharper", "StaticMemberInGenericType")]
-internal static partial class TypeHelper<T0, T1>
+internal static unsafe partial class TypeHelper<T0, T1>
 {
     private static string[]? _typeNames;
     public static string[] TypeNames => _typeNames ??= [ Type<T0>.FullName, Type<T1>.FullName ];
@@ -18,17 +21,20 @@ internal static partial class TypeHelper<T0, T1>
     public static readonly int Tags = (Type<T0>.IsTag ? 1 << 0 : 0) | (Type<T1>.IsTag ? 1 << 1 : 0);
     public static readonly int ReferenceTypes = (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() ? 1 << 0 : 0) | (RuntimeHelpers.IsReferenceOrContainsReferences<T1>() ? 1 << 1 : 0);
     
+    private static string GetTypeListString(int fields)
+    {
+        return string.Join(", ", Enumerable.Range(0, 2)
+            .Where(i => (fields & (1 << i)) != 0)
+            .Select(i => TypeNames[i]));
+    }
+    
     [Conditional("DEBUG")]
     public static void AssertNoTags()
     {
         if (Tags == 0)
             return;
     
-        string tags = string.Join(", ", Enumerable.Range(0, 2)
-            .Where(i => (Tags & (1 << i)) != 0)
-            .Select(i => TypeNames[i]));
-    
-        Ecs.Error($"Cannot use zero-sized structs as generic type arguments for this struct. Remove the following type arguments: {tags}");
+        Ecs.Error($"Cannot use zero-sized structs as generic type arguments for this struct. Remove the following type arguments: {GetTypeListString(Tags)}");
     }
     
     [Conditional("DEBUG")]
@@ -37,10 +43,20 @@ public static void AssertReferenceTypes(bool allowReferenceTypes)
         if (allowReferenceTypes || ReferenceTypes == 0)
             return;
     
-        string referenceTypes = string.Join(", ", Enumerable.Range(0, 2)
-            .Where(i => (ReferenceTypes & (1 << i)) != 0)
-            .Select(i => TypeNames[i]));
+        Ecs.Error($"Cannot use managed types as generic type arguments for callback signatures that retrieve pointers or spans. Remove the following type arguments: {GetTypeListString(ReferenceTypes)}");
+    }
     
-        Ecs.Error($"Cannot use managed types as generic type arguments for callback signatures that retrieve pointers or spans. Remove the following type arguments: {referenceTypes}");
+    [Conditional("DEBUG")]
+    public static void AssertSparseTypes(ecs_world_t* world, bool allowSparseTypes)
+    {
+        if (allowSparseTypes)
+            return;
+ 
+        int sparseTypes = (ecs_has_id(world, Type<T0>.Id(world), Ecs.Sparse) == Utils.True ? 1 << 0 : 0) | (ecs_has_id(world, Type<T1>.Id(world), Ecs.Sparse) == Utils.True ? 1 << 1 : 0);
+ 
+        if (sparseTypes == 0)
+            return;
+ 
+        Ecs.Error($"Cannot use sparse components as generic type arguments for this struct when using .Iter() to iterate because sparse fields must be obtained with Iter.FieldAt(). Use .Each()/.Run() to iterate or remove the following types from the list: {GetTypeListString(sparseTypes)}");
     }
 }
\ No newline at end of file
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/TypeHelper/T10.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/TypeHelper/T10.g.cs
index 6c20856b..6aae44e1 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/TypeHelper/T10.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/TypeHelper/T10.g.cs
@@ -6,11 +6,14 @@
 using System.Diagnostics.CodeAnalysis;
 using System.Linq;
 using System.Runtime.CompilerServices;
+using Flecs.NET.Utilities;
+
+using static Flecs.NET.Bindings.flecs;
 
 namespace Flecs.NET.Core;
 
 [SuppressMessage("ReSharper", "StaticMemberInGenericType")]
-internal static partial class TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>
+internal static unsafe partial class TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>
 {
     private static string[]? _typeNames;
     public static string[] TypeNames => _typeNames ??= [ Type<T0>.FullName, Type<T1>.FullName, Type<T2>.FullName, Type<T3>.FullName, Type<T4>.FullName, Type<T5>.FullName, Type<T6>.FullName, Type<T7>.FullName, Type<T8>.FullName, Type<T9>.FullName, Type<T10>.FullName ];
@@ -18,17 +21,20 @@ internal static partial class TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9,
     public static readonly int Tags = (Type<T0>.IsTag ? 1 << 0 : 0) | (Type<T1>.IsTag ? 1 << 1 : 0) | (Type<T2>.IsTag ? 1 << 2 : 0) | (Type<T3>.IsTag ? 1 << 3 : 0) | (Type<T4>.IsTag ? 1 << 4 : 0) | (Type<T5>.IsTag ? 1 << 5 : 0) | (Type<T6>.IsTag ? 1 << 6 : 0) | (Type<T7>.IsTag ? 1 << 7 : 0) | (Type<T8>.IsTag ? 1 << 8 : 0) | (Type<T9>.IsTag ? 1 << 9 : 0) | (Type<T10>.IsTag ? 1 << 10 : 0);
     public static readonly int ReferenceTypes = (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() ? 1 << 0 : 0) | (RuntimeHelpers.IsReferenceOrContainsReferences<T1>() ? 1 << 1 : 0) | (RuntimeHelpers.IsReferenceOrContainsReferences<T2>() ? 1 << 2 : 0) | (RuntimeHelpers.IsReferenceOrContainsReferences<T3>() ? 1 << 3 : 0) | (RuntimeHelpers.IsReferenceOrContainsReferences<T4>() ? 1 << 4 : 0) | (RuntimeHelpers.IsReferenceOrContainsReferences<T5>() ? 1 << 5 : 0) | (RuntimeHelpers.IsReferenceOrContainsReferences<T6>() ? 1 << 6 : 0) | (RuntimeHelpers.IsReferenceOrContainsReferences<T7>() ? 1 << 7 : 0) | (RuntimeHelpers.IsReferenceOrContainsReferences<T8>() ? 1 << 8 : 0) | (RuntimeHelpers.IsReferenceOrContainsReferences<T9>() ? 1 << 9 : 0) | (RuntimeHelpers.IsReferenceOrContainsReferences<T10>() ? 1 << 10 : 0);
     
+    private static string GetTypeListString(int fields)
+    {
+        return string.Join(", ", Enumerable.Range(0, 11)
+            .Where(i => (fields & (1 << i)) != 0)
+            .Select(i => TypeNames[i]));
+    }
+    
     [Conditional("DEBUG")]
     public static void AssertNoTags()
     {
         if (Tags == 0)
             return;
     
-        string tags = string.Join(", ", Enumerable.Range(0, 11)
-            .Where(i => (Tags & (1 << i)) != 0)
-            .Select(i => TypeNames[i]));
-    
-        Ecs.Error($"Cannot use zero-sized structs as generic type arguments for this struct. Remove the following type arguments: {tags}");
+        Ecs.Error($"Cannot use zero-sized structs as generic type arguments for this struct. Remove the following type arguments: {GetTypeListString(Tags)}");
     }
     
     [Conditional("DEBUG")]
@@ -37,10 +43,20 @@ public static void AssertReferenceTypes(bool allowReferenceTypes)
         if (allowReferenceTypes || ReferenceTypes == 0)
             return;
     
-        string referenceTypes = string.Join(", ", Enumerable.Range(0, 11)
-            .Where(i => (ReferenceTypes & (1 << i)) != 0)
-            .Select(i => TypeNames[i]));
+        Ecs.Error($"Cannot use managed types as generic type arguments for callback signatures that retrieve pointers or spans. Remove the following type arguments: {GetTypeListString(ReferenceTypes)}");
+    }
     
-        Ecs.Error($"Cannot use managed types as generic type arguments for callback signatures that retrieve pointers or spans. Remove the following type arguments: {referenceTypes}");
+    [Conditional("DEBUG")]
+    public static void AssertSparseTypes(ecs_world_t* world, bool allowSparseTypes)
+    {
+        if (allowSparseTypes)
+            return;
+ 
+        int sparseTypes = (ecs_has_id(world, Type<T0>.Id(world), Ecs.Sparse) == Utils.True ? 1 << 0 : 0) | (ecs_has_id(world, Type<T1>.Id(world), Ecs.Sparse) == Utils.True ? 1 << 1 : 0) | (ecs_has_id(world, Type<T2>.Id(world), Ecs.Sparse) == Utils.True ? 1 << 2 : 0) | (ecs_has_id(world, Type<T3>.Id(world), Ecs.Sparse) == Utils.True ? 1 << 3 : 0) | (ecs_has_id(world, Type<T4>.Id(world), Ecs.Sparse) == Utils.True ? 1 << 4 : 0) | (ecs_has_id(world, Type<T5>.Id(world), Ecs.Sparse) == Utils.True ? 1 << 5 : 0) | (ecs_has_id(world, Type<T6>.Id(world), Ecs.Sparse) == Utils.True ? 1 << 6 : 0) | (ecs_has_id(world, Type<T7>.Id(world), Ecs.Sparse) == Utils.True ? 1 << 7 : 0) | (ecs_has_id(world, Type<T8>.Id(world), Ecs.Sparse) == Utils.True ? 1 << 8 : 0) | (ecs_has_id(world, Type<T9>.Id(world), Ecs.Sparse) == Utils.True ? 1 << 9 : 0) | (ecs_has_id(world, Type<T10>.Id(world), Ecs.Sparse) == Utils.True ? 1 << 10 : 0);
+ 
+        if (sparseTypes == 0)
+            return;
+ 
+        Ecs.Error($"Cannot use sparse components as generic type arguments for this struct when using .Iter() to iterate because sparse fields must be obtained with Iter.FieldAt(). Use .Each()/.Run() to iterate or remove the following types from the list: {GetTypeListString(sparseTypes)}");
     }
 }
\ No newline at end of file
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/TypeHelper/T11.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/TypeHelper/T11.g.cs
index 4cfcd380..7bf453f5 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/TypeHelper/T11.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/TypeHelper/T11.g.cs
@@ -6,11 +6,14 @@
 using System.Diagnostics.CodeAnalysis;
 using System.Linq;
 using System.Runtime.CompilerServices;
+using Flecs.NET.Utilities;
+
+using static Flecs.NET.Bindings.flecs;
 
 namespace Flecs.NET.Core;
 
 [SuppressMessage("ReSharper", "StaticMemberInGenericType")]
-internal static partial class TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>
+internal static unsafe partial class TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>
 {
     private static string[]? _typeNames;
     public static string[] TypeNames => _typeNames ??= [ Type<T0>.FullName, Type<T1>.FullName, Type<T2>.FullName, Type<T3>.FullName, Type<T4>.FullName, Type<T5>.FullName, Type<T6>.FullName, Type<T7>.FullName, Type<T8>.FullName, Type<T9>.FullName, Type<T10>.FullName, Type<T11>.FullName ];
@@ -18,17 +21,20 @@ internal static partial class TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9,
     public static readonly int Tags = (Type<T0>.IsTag ? 1 << 0 : 0) | (Type<T1>.IsTag ? 1 << 1 : 0) | (Type<T2>.IsTag ? 1 << 2 : 0) | (Type<T3>.IsTag ? 1 << 3 : 0) | (Type<T4>.IsTag ? 1 << 4 : 0) | (Type<T5>.IsTag ? 1 << 5 : 0) | (Type<T6>.IsTag ? 1 << 6 : 0) | (Type<T7>.IsTag ? 1 << 7 : 0) | (Type<T8>.IsTag ? 1 << 8 : 0) | (Type<T9>.IsTag ? 1 << 9 : 0) | (Type<T10>.IsTag ? 1 << 10 : 0) | (Type<T11>.IsTag ? 1 << 11 : 0);
     public static readonly int ReferenceTypes = (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() ? 1 << 0 : 0) | (RuntimeHelpers.IsReferenceOrContainsReferences<T1>() ? 1 << 1 : 0) | (RuntimeHelpers.IsReferenceOrContainsReferences<T2>() ? 1 << 2 : 0) | (RuntimeHelpers.IsReferenceOrContainsReferences<T3>() ? 1 << 3 : 0) | (RuntimeHelpers.IsReferenceOrContainsReferences<T4>() ? 1 << 4 : 0) | (RuntimeHelpers.IsReferenceOrContainsReferences<T5>() ? 1 << 5 : 0) | (RuntimeHelpers.IsReferenceOrContainsReferences<T6>() ? 1 << 6 : 0) | (RuntimeHelpers.IsReferenceOrContainsReferences<T7>() ? 1 << 7 : 0) | (RuntimeHelpers.IsReferenceOrContainsReferences<T8>() ? 1 << 8 : 0) | (RuntimeHelpers.IsReferenceOrContainsReferences<T9>() ? 1 << 9 : 0) | (RuntimeHelpers.IsReferenceOrContainsReferences<T10>() ? 1 << 10 : 0) | (RuntimeHelpers.IsReferenceOrContainsReferences<T11>() ? 1 << 11 : 0);
     
+    private static string GetTypeListString(int fields)
+    {
+        return string.Join(", ", Enumerable.Range(0, 12)
+            .Where(i => (fields & (1 << i)) != 0)
+            .Select(i => TypeNames[i]));
+    }
+    
     [Conditional("DEBUG")]
     public static void AssertNoTags()
     {
         if (Tags == 0)
             return;
     
-        string tags = string.Join(", ", Enumerable.Range(0, 12)
-            .Where(i => (Tags & (1 << i)) != 0)
-            .Select(i => TypeNames[i]));
-    
-        Ecs.Error($"Cannot use zero-sized structs as generic type arguments for this struct. Remove the following type arguments: {tags}");
+        Ecs.Error($"Cannot use zero-sized structs as generic type arguments for this struct. Remove the following type arguments: {GetTypeListString(Tags)}");
     }
     
     [Conditional("DEBUG")]
@@ -37,10 +43,20 @@ public static void AssertReferenceTypes(bool allowReferenceTypes)
         if (allowReferenceTypes || ReferenceTypes == 0)
             return;
     
-        string referenceTypes = string.Join(", ", Enumerable.Range(0, 12)
-            .Where(i => (ReferenceTypes & (1 << i)) != 0)
-            .Select(i => TypeNames[i]));
+        Ecs.Error($"Cannot use managed types as generic type arguments for callback signatures that retrieve pointers or spans. Remove the following type arguments: {GetTypeListString(ReferenceTypes)}");
+    }
     
-        Ecs.Error($"Cannot use managed types as generic type arguments for callback signatures that retrieve pointers or spans. Remove the following type arguments: {referenceTypes}");
+    [Conditional("DEBUG")]
+    public static void AssertSparseTypes(ecs_world_t* world, bool allowSparseTypes)
+    {
+        if (allowSparseTypes)
+            return;
+ 
+        int sparseTypes = (ecs_has_id(world, Type<T0>.Id(world), Ecs.Sparse) == Utils.True ? 1 << 0 : 0) | (ecs_has_id(world, Type<T1>.Id(world), Ecs.Sparse) == Utils.True ? 1 << 1 : 0) | (ecs_has_id(world, Type<T2>.Id(world), Ecs.Sparse) == Utils.True ? 1 << 2 : 0) | (ecs_has_id(world, Type<T3>.Id(world), Ecs.Sparse) == Utils.True ? 1 << 3 : 0) | (ecs_has_id(world, Type<T4>.Id(world), Ecs.Sparse) == Utils.True ? 1 << 4 : 0) | (ecs_has_id(world, Type<T5>.Id(world), Ecs.Sparse) == Utils.True ? 1 << 5 : 0) | (ecs_has_id(world, Type<T6>.Id(world), Ecs.Sparse) == Utils.True ? 1 << 6 : 0) | (ecs_has_id(world, Type<T7>.Id(world), Ecs.Sparse) == Utils.True ? 1 << 7 : 0) | (ecs_has_id(world, Type<T8>.Id(world), Ecs.Sparse) == Utils.True ? 1 << 8 : 0) | (ecs_has_id(world, Type<T9>.Id(world), Ecs.Sparse) == Utils.True ? 1 << 9 : 0) | (ecs_has_id(world, Type<T10>.Id(world), Ecs.Sparse) == Utils.True ? 1 << 10 : 0) | (ecs_has_id(world, Type<T11>.Id(world), Ecs.Sparse) == Utils.True ? 1 << 11 : 0);
+ 
+        if (sparseTypes == 0)
+            return;
+ 
+        Ecs.Error($"Cannot use sparse components as generic type arguments for this struct when using .Iter() to iterate because sparse fields must be obtained with Iter.FieldAt(). Use .Each()/.Run() to iterate or remove the following types from the list: {GetTypeListString(sparseTypes)}");
     }
 }
\ No newline at end of file
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/TypeHelper/T12.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/TypeHelper/T12.g.cs
index 1e04df60..5ee5a2d1 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/TypeHelper/T12.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/TypeHelper/T12.g.cs
@@ -6,11 +6,14 @@
 using System.Diagnostics.CodeAnalysis;
 using System.Linq;
 using System.Runtime.CompilerServices;
+using Flecs.NET.Utilities;
+
+using static Flecs.NET.Bindings.flecs;
 
 namespace Flecs.NET.Core;
 
 [SuppressMessage("ReSharper", "StaticMemberInGenericType")]
-internal static partial class TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>
+internal static unsafe partial class TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>
 {
     private static string[]? _typeNames;
     public static string[] TypeNames => _typeNames ??= [ Type<T0>.FullName, Type<T1>.FullName, Type<T2>.FullName, Type<T3>.FullName, Type<T4>.FullName, Type<T5>.FullName, Type<T6>.FullName, Type<T7>.FullName, Type<T8>.FullName, Type<T9>.FullName, Type<T10>.FullName, Type<T11>.FullName, Type<T12>.FullName ];
@@ -18,17 +21,20 @@ internal static partial class TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9,
     public static readonly int Tags = (Type<T0>.IsTag ? 1 << 0 : 0) | (Type<T1>.IsTag ? 1 << 1 : 0) | (Type<T2>.IsTag ? 1 << 2 : 0) | (Type<T3>.IsTag ? 1 << 3 : 0) | (Type<T4>.IsTag ? 1 << 4 : 0) | (Type<T5>.IsTag ? 1 << 5 : 0) | (Type<T6>.IsTag ? 1 << 6 : 0) | (Type<T7>.IsTag ? 1 << 7 : 0) | (Type<T8>.IsTag ? 1 << 8 : 0) | (Type<T9>.IsTag ? 1 << 9 : 0) | (Type<T10>.IsTag ? 1 << 10 : 0) | (Type<T11>.IsTag ? 1 << 11 : 0) | (Type<T12>.IsTag ? 1 << 12 : 0);
     public static readonly int ReferenceTypes = (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() ? 1 << 0 : 0) | (RuntimeHelpers.IsReferenceOrContainsReferences<T1>() ? 1 << 1 : 0) | (RuntimeHelpers.IsReferenceOrContainsReferences<T2>() ? 1 << 2 : 0) | (RuntimeHelpers.IsReferenceOrContainsReferences<T3>() ? 1 << 3 : 0) | (RuntimeHelpers.IsReferenceOrContainsReferences<T4>() ? 1 << 4 : 0) | (RuntimeHelpers.IsReferenceOrContainsReferences<T5>() ? 1 << 5 : 0) | (RuntimeHelpers.IsReferenceOrContainsReferences<T6>() ? 1 << 6 : 0) | (RuntimeHelpers.IsReferenceOrContainsReferences<T7>() ? 1 << 7 : 0) | (RuntimeHelpers.IsReferenceOrContainsReferences<T8>() ? 1 << 8 : 0) | (RuntimeHelpers.IsReferenceOrContainsReferences<T9>() ? 1 << 9 : 0) | (RuntimeHelpers.IsReferenceOrContainsReferences<T10>() ? 1 << 10 : 0) | (RuntimeHelpers.IsReferenceOrContainsReferences<T11>() ? 1 << 11 : 0) | (RuntimeHelpers.IsReferenceOrContainsReferences<T12>() ? 1 << 12 : 0);
     
+    private static string GetTypeListString(int fields)
+    {
+        return string.Join(", ", Enumerable.Range(0, 13)
+            .Where(i => (fields & (1 << i)) != 0)
+            .Select(i => TypeNames[i]));
+    }
+    
     [Conditional("DEBUG")]
     public static void AssertNoTags()
     {
         if (Tags == 0)
             return;
     
-        string tags = string.Join(", ", Enumerable.Range(0, 13)
-            .Where(i => (Tags & (1 << i)) != 0)
-            .Select(i => TypeNames[i]));
-    
-        Ecs.Error($"Cannot use zero-sized structs as generic type arguments for this struct. Remove the following type arguments: {tags}");
+        Ecs.Error($"Cannot use zero-sized structs as generic type arguments for this struct. Remove the following type arguments: {GetTypeListString(Tags)}");
     }
     
     [Conditional("DEBUG")]
@@ -37,10 +43,20 @@ public static void AssertReferenceTypes(bool allowReferenceTypes)
         if (allowReferenceTypes || ReferenceTypes == 0)
             return;
     
-        string referenceTypes = string.Join(", ", Enumerable.Range(0, 13)
-            .Where(i => (ReferenceTypes & (1 << i)) != 0)
-            .Select(i => TypeNames[i]));
+        Ecs.Error($"Cannot use managed types as generic type arguments for callback signatures that retrieve pointers or spans. Remove the following type arguments: {GetTypeListString(ReferenceTypes)}");
+    }
     
-        Ecs.Error($"Cannot use managed types as generic type arguments for callback signatures that retrieve pointers or spans. Remove the following type arguments: {referenceTypes}");
+    [Conditional("DEBUG")]
+    public static void AssertSparseTypes(ecs_world_t* world, bool allowSparseTypes)
+    {
+        if (allowSparseTypes)
+            return;
+ 
+        int sparseTypes = (ecs_has_id(world, Type<T0>.Id(world), Ecs.Sparse) == Utils.True ? 1 << 0 : 0) | (ecs_has_id(world, Type<T1>.Id(world), Ecs.Sparse) == Utils.True ? 1 << 1 : 0) | (ecs_has_id(world, Type<T2>.Id(world), Ecs.Sparse) == Utils.True ? 1 << 2 : 0) | (ecs_has_id(world, Type<T3>.Id(world), Ecs.Sparse) == Utils.True ? 1 << 3 : 0) | (ecs_has_id(world, Type<T4>.Id(world), Ecs.Sparse) == Utils.True ? 1 << 4 : 0) | (ecs_has_id(world, Type<T5>.Id(world), Ecs.Sparse) == Utils.True ? 1 << 5 : 0) | (ecs_has_id(world, Type<T6>.Id(world), Ecs.Sparse) == Utils.True ? 1 << 6 : 0) | (ecs_has_id(world, Type<T7>.Id(world), Ecs.Sparse) == Utils.True ? 1 << 7 : 0) | (ecs_has_id(world, Type<T8>.Id(world), Ecs.Sparse) == Utils.True ? 1 << 8 : 0) | (ecs_has_id(world, Type<T9>.Id(world), Ecs.Sparse) == Utils.True ? 1 << 9 : 0) | (ecs_has_id(world, Type<T10>.Id(world), Ecs.Sparse) == Utils.True ? 1 << 10 : 0) | (ecs_has_id(world, Type<T11>.Id(world), Ecs.Sparse) == Utils.True ? 1 << 11 : 0) | (ecs_has_id(world, Type<T12>.Id(world), Ecs.Sparse) == Utils.True ? 1 << 12 : 0);
+ 
+        if (sparseTypes == 0)
+            return;
+ 
+        Ecs.Error($"Cannot use sparse components as generic type arguments for this struct when using .Iter() to iterate because sparse fields must be obtained with Iter.FieldAt(). Use .Each()/.Run() to iterate or remove the following types from the list: {GetTypeListString(sparseTypes)}");
     }
 }
\ No newline at end of file
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/TypeHelper/T13.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/TypeHelper/T13.g.cs
index c858281a..cfb8d469 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/TypeHelper/T13.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/TypeHelper/T13.g.cs
@@ -6,11 +6,14 @@
 using System.Diagnostics.CodeAnalysis;
 using System.Linq;
 using System.Runtime.CompilerServices;
+using Flecs.NET.Utilities;
+
+using static Flecs.NET.Bindings.flecs;
 
 namespace Flecs.NET.Core;
 
 [SuppressMessage("ReSharper", "StaticMemberInGenericType")]
-internal static partial class TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>
+internal static unsafe partial class TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>
 {
     private static string[]? _typeNames;
     public static string[] TypeNames => _typeNames ??= [ Type<T0>.FullName, Type<T1>.FullName, Type<T2>.FullName, Type<T3>.FullName, Type<T4>.FullName, Type<T5>.FullName, Type<T6>.FullName, Type<T7>.FullName, Type<T8>.FullName, Type<T9>.FullName, Type<T10>.FullName, Type<T11>.FullName, Type<T12>.FullName, Type<T13>.FullName ];
@@ -18,17 +21,20 @@ internal static partial class TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9,
     public static readonly int Tags = (Type<T0>.IsTag ? 1 << 0 : 0) | (Type<T1>.IsTag ? 1 << 1 : 0) | (Type<T2>.IsTag ? 1 << 2 : 0) | (Type<T3>.IsTag ? 1 << 3 : 0) | (Type<T4>.IsTag ? 1 << 4 : 0) | (Type<T5>.IsTag ? 1 << 5 : 0) | (Type<T6>.IsTag ? 1 << 6 : 0) | (Type<T7>.IsTag ? 1 << 7 : 0) | (Type<T8>.IsTag ? 1 << 8 : 0) | (Type<T9>.IsTag ? 1 << 9 : 0) | (Type<T10>.IsTag ? 1 << 10 : 0) | (Type<T11>.IsTag ? 1 << 11 : 0) | (Type<T12>.IsTag ? 1 << 12 : 0) | (Type<T13>.IsTag ? 1 << 13 : 0);
     public static readonly int ReferenceTypes = (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() ? 1 << 0 : 0) | (RuntimeHelpers.IsReferenceOrContainsReferences<T1>() ? 1 << 1 : 0) | (RuntimeHelpers.IsReferenceOrContainsReferences<T2>() ? 1 << 2 : 0) | (RuntimeHelpers.IsReferenceOrContainsReferences<T3>() ? 1 << 3 : 0) | (RuntimeHelpers.IsReferenceOrContainsReferences<T4>() ? 1 << 4 : 0) | (RuntimeHelpers.IsReferenceOrContainsReferences<T5>() ? 1 << 5 : 0) | (RuntimeHelpers.IsReferenceOrContainsReferences<T6>() ? 1 << 6 : 0) | (RuntimeHelpers.IsReferenceOrContainsReferences<T7>() ? 1 << 7 : 0) | (RuntimeHelpers.IsReferenceOrContainsReferences<T8>() ? 1 << 8 : 0) | (RuntimeHelpers.IsReferenceOrContainsReferences<T9>() ? 1 << 9 : 0) | (RuntimeHelpers.IsReferenceOrContainsReferences<T10>() ? 1 << 10 : 0) | (RuntimeHelpers.IsReferenceOrContainsReferences<T11>() ? 1 << 11 : 0) | (RuntimeHelpers.IsReferenceOrContainsReferences<T12>() ? 1 << 12 : 0) | (RuntimeHelpers.IsReferenceOrContainsReferences<T13>() ? 1 << 13 : 0);
     
+    private static string GetTypeListString(int fields)
+    {
+        return string.Join(", ", Enumerable.Range(0, 14)
+            .Where(i => (fields & (1 << i)) != 0)
+            .Select(i => TypeNames[i]));
+    }
+    
     [Conditional("DEBUG")]
     public static void AssertNoTags()
     {
         if (Tags == 0)
             return;
     
-        string tags = string.Join(", ", Enumerable.Range(0, 14)
-            .Where(i => (Tags & (1 << i)) != 0)
-            .Select(i => TypeNames[i]));
-    
-        Ecs.Error($"Cannot use zero-sized structs as generic type arguments for this struct. Remove the following type arguments: {tags}");
+        Ecs.Error($"Cannot use zero-sized structs as generic type arguments for this struct. Remove the following type arguments: {GetTypeListString(Tags)}");
     }
     
     [Conditional("DEBUG")]
@@ -37,10 +43,20 @@ public static void AssertReferenceTypes(bool allowReferenceTypes)
         if (allowReferenceTypes || ReferenceTypes == 0)
             return;
     
-        string referenceTypes = string.Join(", ", Enumerable.Range(0, 14)
-            .Where(i => (ReferenceTypes & (1 << i)) != 0)
-            .Select(i => TypeNames[i]));
+        Ecs.Error($"Cannot use managed types as generic type arguments for callback signatures that retrieve pointers or spans. Remove the following type arguments: {GetTypeListString(ReferenceTypes)}");
+    }
     
-        Ecs.Error($"Cannot use managed types as generic type arguments for callback signatures that retrieve pointers or spans. Remove the following type arguments: {referenceTypes}");
+    [Conditional("DEBUG")]
+    public static void AssertSparseTypes(ecs_world_t* world, bool allowSparseTypes)
+    {
+        if (allowSparseTypes)
+            return;
+ 
+        int sparseTypes = (ecs_has_id(world, Type<T0>.Id(world), Ecs.Sparse) == Utils.True ? 1 << 0 : 0) | (ecs_has_id(world, Type<T1>.Id(world), Ecs.Sparse) == Utils.True ? 1 << 1 : 0) | (ecs_has_id(world, Type<T2>.Id(world), Ecs.Sparse) == Utils.True ? 1 << 2 : 0) | (ecs_has_id(world, Type<T3>.Id(world), Ecs.Sparse) == Utils.True ? 1 << 3 : 0) | (ecs_has_id(world, Type<T4>.Id(world), Ecs.Sparse) == Utils.True ? 1 << 4 : 0) | (ecs_has_id(world, Type<T5>.Id(world), Ecs.Sparse) == Utils.True ? 1 << 5 : 0) | (ecs_has_id(world, Type<T6>.Id(world), Ecs.Sparse) == Utils.True ? 1 << 6 : 0) | (ecs_has_id(world, Type<T7>.Id(world), Ecs.Sparse) == Utils.True ? 1 << 7 : 0) | (ecs_has_id(world, Type<T8>.Id(world), Ecs.Sparse) == Utils.True ? 1 << 8 : 0) | (ecs_has_id(world, Type<T9>.Id(world), Ecs.Sparse) == Utils.True ? 1 << 9 : 0) | (ecs_has_id(world, Type<T10>.Id(world), Ecs.Sparse) == Utils.True ? 1 << 10 : 0) | (ecs_has_id(world, Type<T11>.Id(world), Ecs.Sparse) == Utils.True ? 1 << 11 : 0) | (ecs_has_id(world, Type<T12>.Id(world), Ecs.Sparse) == Utils.True ? 1 << 12 : 0) | (ecs_has_id(world, Type<T13>.Id(world), Ecs.Sparse) == Utils.True ? 1 << 13 : 0);
+ 
+        if (sparseTypes == 0)
+            return;
+ 
+        Ecs.Error($"Cannot use sparse components as generic type arguments for this struct when using .Iter() to iterate because sparse fields must be obtained with Iter.FieldAt(). Use .Each()/.Run() to iterate or remove the following types from the list: {GetTypeListString(sparseTypes)}");
     }
 }
\ No newline at end of file
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/TypeHelper/T14.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/TypeHelper/T14.g.cs
index 086337a8..b0776938 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/TypeHelper/T14.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/TypeHelper/T14.g.cs
@@ -6,11 +6,14 @@
 using System.Diagnostics.CodeAnalysis;
 using System.Linq;
 using System.Runtime.CompilerServices;
+using Flecs.NET.Utilities;
+
+using static Flecs.NET.Bindings.flecs;
 
 namespace Flecs.NET.Core;
 
 [SuppressMessage("ReSharper", "StaticMemberInGenericType")]
-internal static partial class TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>
+internal static unsafe partial class TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>
 {
     private static string[]? _typeNames;
     public static string[] TypeNames => _typeNames ??= [ Type<T0>.FullName, Type<T1>.FullName, Type<T2>.FullName, Type<T3>.FullName, Type<T4>.FullName, Type<T5>.FullName, Type<T6>.FullName, Type<T7>.FullName, Type<T8>.FullName, Type<T9>.FullName, Type<T10>.FullName, Type<T11>.FullName, Type<T12>.FullName, Type<T13>.FullName, Type<T14>.FullName ];
@@ -18,17 +21,20 @@ internal static partial class TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9,
     public static readonly int Tags = (Type<T0>.IsTag ? 1 << 0 : 0) | (Type<T1>.IsTag ? 1 << 1 : 0) | (Type<T2>.IsTag ? 1 << 2 : 0) | (Type<T3>.IsTag ? 1 << 3 : 0) | (Type<T4>.IsTag ? 1 << 4 : 0) | (Type<T5>.IsTag ? 1 << 5 : 0) | (Type<T6>.IsTag ? 1 << 6 : 0) | (Type<T7>.IsTag ? 1 << 7 : 0) | (Type<T8>.IsTag ? 1 << 8 : 0) | (Type<T9>.IsTag ? 1 << 9 : 0) | (Type<T10>.IsTag ? 1 << 10 : 0) | (Type<T11>.IsTag ? 1 << 11 : 0) | (Type<T12>.IsTag ? 1 << 12 : 0) | (Type<T13>.IsTag ? 1 << 13 : 0) | (Type<T14>.IsTag ? 1 << 14 : 0);
     public static readonly int ReferenceTypes = (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() ? 1 << 0 : 0) | (RuntimeHelpers.IsReferenceOrContainsReferences<T1>() ? 1 << 1 : 0) | (RuntimeHelpers.IsReferenceOrContainsReferences<T2>() ? 1 << 2 : 0) | (RuntimeHelpers.IsReferenceOrContainsReferences<T3>() ? 1 << 3 : 0) | (RuntimeHelpers.IsReferenceOrContainsReferences<T4>() ? 1 << 4 : 0) | (RuntimeHelpers.IsReferenceOrContainsReferences<T5>() ? 1 << 5 : 0) | (RuntimeHelpers.IsReferenceOrContainsReferences<T6>() ? 1 << 6 : 0) | (RuntimeHelpers.IsReferenceOrContainsReferences<T7>() ? 1 << 7 : 0) | (RuntimeHelpers.IsReferenceOrContainsReferences<T8>() ? 1 << 8 : 0) | (RuntimeHelpers.IsReferenceOrContainsReferences<T9>() ? 1 << 9 : 0) | (RuntimeHelpers.IsReferenceOrContainsReferences<T10>() ? 1 << 10 : 0) | (RuntimeHelpers.IsReferenceOrContainsReferences<T11>() ? 1 << 11 : 0) | (RuntimeHelpers.IsReferenceOrContainsReferences<T12>() ? 1 << 12 : 0) | (RuntimeHelpers.IsReferenceOrContainsReferences<T13>() ? 1 << 13 : 0) | (RuntimeHelpers.IsReferenceOrContainsReferences<T14>() ? 1 << 14 : 0);
     
+    private static string GetTypeListString(int fields)
+    {
+        return string.Join(", ", Enumerable.Range(0, 15)
+            .Where(i => (fields & (1 << i)) != 0)
+            .Select(i => TypeNames[i]));
+    }
+    
     [Conditional("DEBUG")]
     public static void AssertNoTags()
     {
         if (Tags == 0)
             return;
     
-        string tags = string.Join(", ", Enumerable.Range(0, 15)
-            .Where(i => (Tags & (1 << i)) != 0)
-            .Select(i => TypeNames[i]));
-    
-        Ecs.Error($"Cannot use zero-sized structs as generic type arguments for this struct. Remove the following type arguments: {tags}");
+        Ecs.Error($"Cannot use zero-sized structs as generic type arguments for this struct. Remove the following type arguments: {GetTypeListString(Tags)}");
     }
     
     [Conditional("DEBUG")]
@@ -37,10 +43,20 @@ public static void AssertReferenceTypes(bool allowReferenceTypes)
         if (allowReferenceTypes || ReferenceTypes == 0)
             return;
     
-        string referenceTypes = string.Join(", ", Enumerable.Range(0, 15)
-            .Where(i => (ReferenceTypes & (1 << i)) != 0)
-            .Select(i => TypeNames[i]));
+        Ecs.Error($"Cannot use managed types as generic type arguments for callback signatures that retrieve pointers or spans. Remove the following type arguments: {GetTypeListString(ReferenceTypes)}");
+    }
     
-        Ecs.Error($"Cannot use managed types as generic type arguments for callback signatures that retrieve pointers or spans. Remove the following type arguments: {referenceTypes}");
+    [Conditional("DEBUG")]
+    public static void AssertSparseTypes(ecs_world_t* world, bool allowSparseTypes)
+    {
+        if (allowSparseTypes)
+            return;
+ 
+        int sparseTypes = (ecs_has_id(world, Type<T0>.Id(world), Ecs.Sparse) == Utils.True ? 1 << 0 : 0) | (ecs_has_id(world, Type<T1>.Id(world), Ecs.Sparse) == Utils.True ? 1 << 1 : 0) | (ecs_has_id(world, Type<T2>.Id(world), Ecs.Sparse) == Utils.True ? 1 << 2 : 0) | (ecs_has_id(world, Type<T3>.Id(world), Ecs.Sparse) == Utils.True ? 1 << 3 : 0) | (ecs_has_id(world, Type<T4>.Id(world), Ecs.Sparse) == Utils.True ? 1 << 4 : 0) | (ecs_has_id(world, Type<T5>.Id(world), Ecs.Sparse) == Utils.True ? 1 << 5 : 0) | (ecs_has_id(world, Type<T6>.Id(world), Ecs.Sparse) == Utils.True ? 1 << 6 : 0) | (ecs_has_id(world, Type<T7>.Id(world), Ecs.Sparse) == Utils.True ? 1 << 7 : 0) | (ecs_has_id(world, Type<T8>.Id(world), Ecs.Sparse) == Utils.True ? 1 << 8 : 0) | (ecs_has_id(world, Type<T9>.Id(world), Ecs.Sparse) == Utils.True ? 1 << 9 : 0) | (ecs_has_id(world, Type<T10>.Id(world), Ecs.Sparse) == Utils.True ? 1 << 10 : 0) | (ecs_has_id(world, Type<T11>.Id(world), Ecs.Sparse) == Utils.True ? 1 << 11 : 0) | (ecs_has_id(world, Type<T12>.Id(world), Ecs.Sparse) == Utils.True ? 1 << 12 : 0) | (ecs_has_id(world, Type<T13>.Id(world), Ecs.Sparse) == Utils.True ? 1 << 13 : 0) | (ecs_has_id(world, Type<T14>.Id(world), Ecs.Sparse) == Utils.True ? 1 << 14 : 0);
+ 
+        if (sparseTypes == 0)
+            return;
+ 
+        Ecs.Error($"Cannot use sparse components as generic type arguments for this struct when using .Iter() to iterate because sparse fields must be obtained with Iter.FieldAt(). Use .Each()/.Run() to iterate or remove the following types from the list: {GetTypeListString(sparseTypes)}");
     }
 }
\ No newline at end of file
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/TypeHelper/T15.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/TypeHelper/T15.g.cs
index fe1f5575..98deb813 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/TypeHelper/T15.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/TypeHelper/T15.g.cs
@@ -6,11 +6,14 @@
 using System.Diagnostics.CodeAnalysis;
 using System.Linq;
 using System.Runtime.CompilerServices;
+using Flecs.NET.Utilities;
+
+using static Flecs.NET.Bindings.flecs;
 
 namespace Flecs.NET.Core;
 
 [SuppressMessage("ReSharper", "StaticMemberInGenericType")]
-internal static partial class TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>
+internal static unsafe partial class TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>
 {
     private static string[]? _typeNames;
     public static string[] TypeNames => _typeNames ??= [ Type<T0>.FullName, Type<T1>.FullName, Type<T2>.FullName, Type<T3>.FullName, Type<T4>.FullName, Type<T5>.FullName, Type<T6>.FullName, Type<T7>.FullName, Type<T8>.FullName, Type<T9>.FullName, Type<T10>.FullName, Type<T11>.FullName, Type<T12>.FullName, Type<T13>.FullName, Type<T14>.FullName, Type<T15>.FullName ];
@@ -18,17 +21,20 @@ internal static partial class TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9,
     public static readonly int Tags = (Type<T0>.IsTag ? 1 << 0 : 0) | (Type<T1>.IsTag ? 1 << 1 : 0) | (Type<T2>.IsTag ? 1 << 2 : 0) | (Type<T3>.IsTag ? 1 << 3 : 0) | (Type<T4>.IsTag ? 1 << 4 : 0) | (Type<T5>.IsTag ? 1 << 5 : 0) | (Type<T6>.IsTag ? 1 << 6 : 0) | (Type<T7>.IsTag ? 1 << 7 : 0) | (Type<T8>.IsTag ? 1 << 8 : 0) | (Type<T9>.IsTag ? 1 << 9 : 0) | (Type<T10>.IsTag ? 1 << 10 : 0) | (Type<T11>.IsTag ? 1 << 11 : 0) | (Type<T12>.IsTag ? 1 << 12 : 0) | (Type<T13>.IsTag ? 1 << 13 : 0) | (Type<T14>.IsTag ? 1 << 14 : 0) | (Type<T15>.IsTag ? 1 << 15 : 0);
     public static readonly int ReferenceTypes = (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() ? 1 << 0 : 0) | (RuntimeHelpers.IsReferenceOrContainsReferences<T1>() ? 1 << 1 : 0) | (RuntimeHelpers.IsReferenceOrContainsReferences<T2>() ? 1 << 2 : 0) | (RuntimeHelpers.IsReferenceOrContainsReferences<T3>() ? 1 << 3 : 0) | (RuntimeHelpers.IsReferenceOrContainsReferences<T4>() ? 1 << 4 : 0) | (RuntimeHelpers.IsReferenceOrContainsReferences<T5>() ? 1 << 5 : 0) | (RuntimeHelpers.IsReferenceOrContainsReferences<T6>() ? 1 << 6 : 0) | (RuntimeHelpers.IsReferenceOrContainsReferences<T7>() ? 1 << 7 : 0) | (RuntimeHelpers.IsReferenceOrContainsReferences<T8>() ? 1 << 8 : 0) | (RuntimeHelpers.IsReferenceOrContainsReferences<T9>() ? 1 << 9 : 0) | (RuntimeHelpers.IsReferenceOrContainsReferences<T10>() ? 1 << 10 : 0) | (RuntimeHelpers.IsReferenceOrContainsReferences<T11>() ? 1 << 11 : 0) | (RuntimeHelpers.IsReferenceOrContainsReferences<T12>() ? 1 << 12 : 0) | (RuntimeHelpers.IsReferenceOrContainsReferences<T13>() ? 1 << 13 : 0) | (RuntimeHelpers.IsReferenceOrContainsReferences<T14>() ? 1 << 14 : 0) | (RuntimeHelpers.IsReferenceOrContainsReferences<T15>() ? 1 << 15 : 0);
     
+    private static string GetTypeListString(int fields)
+    {
+        return string.Join(", ", Enumerable.Range(0, 16)
+            .Where(i => (fields & (1 << i)) != 0)
+            .Select(i => TypeNames[i]));
+    }
+    
     [Conditional("DEBUG")]
     public static void AssertNoTags()
     {
         if (Tags == 0)
             return;
     
-        string tags = string.Join(", ", Enumerable.Range(0, 16)
-            .Where(i => (Tags & (1 << i)) != 0)
-            .Select(i => TypeNames[i]));
-    
-        Ecs.Error($"Cannot use zero-sized structs as generic type arguments for this struct. Remove the following type arguments: {tags}");
+        Ecs.Error($"Cannot use zero-sized structs as generic type arguments for this struct. Remove the following type arguments: {GetTypeListString(Tags)}");
     }
     
     [Conditional("DEBUG")]
@@ -37,10 +43,20 @@ public static void AssertReferenceTypes(bool allowReferenceTypes)
         if (allowReferenceTypes || ReferenceTypes == 0)
             return;
     
-        string referenceTypes = string.Join(", ", Enumerable.Range(0, 16)
-            .Where(i => (ReferenceTypes & (1 << i)) != 0)
-            .Select(i => TypeNames[i]));
+        Ecs.Error($"Cannot use managed types as generic type arguments for callback signatures that retrieve pointers or spans. Remove the following type arguments: {GetTypeListString(ReferenceTypes)}");
+    }
     
-        Ecs.Error($"Cannot use managed types as generic type arguments for callback signatures that retrieve pointers or spans. Remove the following type arguments: {referenceTypes}");
+    [Conditional("DEBUG")]
+    public static void AssertSparseTypes(ecs_world_t* world, bool allowSparseTypes)
+    {
+        if (allowSparseTypes)
+            return;
+ 
+        int sparseTypes = (ecs_has_id(world, Type<T0>.Id(world), Ecs.Sparse) == Utils.True ? 1 << 0 : 0) | (ecs_has_id(world, Type<T1>.Id(world), Ecs.Sparse) == Utils.True ? 1 << 1 : 0) | (ecs_has_id(world, Type<T2>.Id(world), Ecs.Sparse) == Utils.True ? 1 << 2 : 0) | (ecs_has_id(world, Type<T3>.Id(world), Ecs.Sparse) == Utils.True ? 1 << 3 : 0) | (ecs_has_id(world, Type<T4>.Id(world), Ecs.Sparse) == Utils.True ? 1 << 4 : 0) | (ecs_has_id(world, Type<T5>.Id(world), Ecs.Sparse) == Utils.True ? 1 << 5 : 0) | (ecs_has_id(world, Type<T6>.Id(world), Ecs.Sparse) == Utils.True ? 1 << 6 : 0) | (ecs_has_id(world, Type<T7>.Id(world), Ecs.Sparse) == Utils.True ? 1 << 7 : 0) | (ecs_has_id(world, Type<T8>.Id(world), Ecs.Sparse) == Utils.True ? 1 << 8 : 0) | (ecs_has_id(world, Type<T9>.Id(world), Ecs.Sparse) == Utils.True ? 1 << 9 : 0) | (ecs_has_id(world, Type<T10>.Id(world), Ecs.Sparse) == Utils.True ? 1 << 10 : 0) | (ecs_has_id(world, Type<T11>.Id(world), Ecs.Sparse) == Utils.True ? 1 << 11 : 0) | (ecs_has_id(world, Type<T12>.Id(world), Ecs.Sparse) == Utils.True ? 1 << 12 : 0) | (ecs_has_id(world, Type<T13>.Id(world), Ecs.Sparse) == Utils.True ? 1 << 13 : 0) | (ecs_has_id(world, Type<T14>.Id(world), Ecs.Sparse) == Utils.True ? 1 << 14 : 0) | (ecs_has_id(world, Type<T15>.Id(world), Ecs.Sparse) == Utils.True ? 1 << 15 : 0);
+ 
+        if (sparseTypes == 0)
+            return;
+ 
+        Ecs.Error($"Cannot use sparse components as generic type arguments for this struct when using .Iter() to iterate because sparse fields must be obtained with Iter.FieldAt(). Use .Each()/.Run() to iterate or remove the following types from the list: {GetTypeListString(sparseTypes)}");
     }
 }
\ No newline at end of file
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/TypeHelper/T2.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/TypeHelper/T2.g.cs
index cf82d958..d8be6445 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/TypeHelper/T2.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/TypeHelper/T2.g.cs
@@ -6,11 +6,14 @@
 using System.Diagnostics.CodeAnalysis;
 using System.Linq;
 using System.Runtime.CompilerServices;
+using Flecs.NET.Utilities;
+
+using static Flecs.NET.Bindings.flecs;
 
 namespace Flecs.NET.Core;
 
 [SuppressMessage("ReSharper", "StaticMemberInGenericType")]
-internal static partial class TypeHelper<T0, T1, T2>
+internal static unsafe partial class TypeHelper<T0, T1, T2>
 {
     private static string[]? _typeNames;
     public static string[] TypeNames => _typeNames ??= [ Type<T0>.FullName, Type<T1>.FullName, Type<T2>.FullName ];
@@ -18,17 +21,20 @@ internal static partial class TypeHelper<T0, T1, T2>
     public static readonly int Tags = (Type<T0>.IsTag ? 1 << 0 : 0) | (Type<T1>.IsTag ? 1 << 1 : 0) | (Type<T2>.IsTag ? 1 << 2 : 0);
     public static readonly int ReferenceTypes = (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() ? 1 << 0 : 0) | (RuntimeHelpers.IsReferenceOrContainsReferences<T1>() ? 1 << 1 : 0) | (RuntimeHelpers.IsReferenceOrContainsReferences<T2>() ? 1 << 2 : 0);
     
+    private static string GetTypeListString(int fields)
+    {
+        return string.Join(", ", Enumerable.Range(0, 3)
+            .Where(i => (fields & (1 << i)) != 0)
+            .Select(i => TypeNames[i]));
+    }
+    
     [Conditional("DEBUG")]
     public static void AssertNoTags()
     {
         if (Tags == 0)
             return;
     
-        string tags = string.Join(", ", Enumerable.Range(0, 3)
-            .Where(i => (Tags & (1 << i)) != 0)
-            .Select(i => TypeNames[i]));
-    
-        Ecs.Error($"Cannot use zero-sized structs as generic type arguments for this struct. Remove the following type arguments: {tags}");
+        Ecs.Error($"Cannot use zero-sized structs as generic type arguments for this struct. Remove the following type arguments: {GetTypeListString(Tags)}");
     }
     
     [Conditional("DEBUG")]
@@ -37,10 +43,20 @@ public static void AssertReferenceTypes(bool allowReferenceTypes)
         if (allowReferenceTypes || ReferenceTypes == 0)
             return;
     
-        string referenceTypes = string.Join(", ", Enumerable.Range(0, 3)
-            .Where(i => (ReferenceTypes & (1 << i)) != 0)
-            .Select(i => TypeNames[i]));
+        Ecs.Error($"Cannot use managed types as generic type arguments for callback signatures that retrieve pointers or spans. Remove the following type arguments: {GetTypeListString(ReferenceTypes)}");
+    }
     
-        Ecs.Error($"Cannot use managed types as generic type arguments for callback signatures that retrieve pointers or spans. Remove the following type arguments: {referenceTypes}");
+    [Conditional("DEBUG")]
+    public static void AssertSparseTypes(ecs_world_t* world, bool allowSparseTypes)
+    {
+        if (allowSparseTypes)
+            return;
+ 
+        int sparseTypes = (ecs_has_id(world, Type<T0>.Id(world), Ecs.Sparse) == Utils.True ? 1 << 0 : 0) | (ecs_has_id(world, Type<T1>.Id(world), Ecs.Sparse) == Utils.True ? 1 << 1 : 0) | (ecs_has_id(world, Type<T2>.Id(world), Ecs.Sparse) == Utils.True ? 1 << 2 : 0);
+ 
+        if (sparseTypes == 0)
+            return;
+ 
+        Ecs.Error($"Cannot use sparse components as generic type arguments for this struct when using .Iter() to iterate because sparse fields must be obtained with Iter.FieldAt(). Use .Each()/.Run() to iterate or remove the following types from the list: {GetTypeListString(sparseTypes)}");
     }
 }
\ No newline at end of file
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/TypeHelper/T3.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/TypeHelper/T3.g.cs
index 3d1411da..5651affa 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/TypeHelper/T3.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/TypeHelper/T3.g.cs
@@ -6,11 +6,14 @@
 using System.Diagnostics.CodeAnalysis;
 using System.Linq;
 using System.Runtime.CompilerServices;
+using Flecs.NET.Utilities;
+
+using static Flecs.NET.Bindings.flecs;
 
 namespace Flecs.NET.Core;
 
 [SuppressMessage("ReSharper", "StaticMemberInGenericType")]
-internal static partial class TypeHelper<T0, T1, T2, T3>
+internal static unsafe partial class TypeHelper<T0, T1, T2, T3>
 {
     private static string[]? _typeNames;
     public static string[] TypeNames => _typeNames ??= [ Type<T0>.FullName, Type<T1>.FullName, Type<T2>.FullName, Type<T3>.FullName ];
@@ -18,17 +21,20 @@ internal static partial class TypeHelper<T0, T1, T2, T3>
     public static readonly int Tags = (Type<T0>.IsTag ? 1 << 0 : 0) | (Type<T1>.IsTag ? 1 << 1 : 0) | (Type<T2>.IsTag ? 1 << 2 : 0) | (Type<T3>.IsTag ? 1 << 3 : 0);
     public static readonly int ReferenceTypes = (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() ? 1 << 0 : 0) | (RuntimeHelpers.IsReferenceOrContainsReferences<T1>() ? 1 << 1 : 0) | (RuntimeHelpers.IsReferenceOrContainsReferences<T2>() ? 1 << 2 : 0) | (RuntimeHelpers.IsReferenceOrContainsReferences<T3>() ? 1 << 3 : 0);
     
+    private static string GetTypeListString(int fields)
+    {
+        return string.Join(", ", Enumerable.Range(0, 4)
+            .Where(i => (fields & (1 << i)) != 0)
+            .Select(i => TypeNames[i]));
+    }
+    
     [Conditional("DEBUG")]
     public static void AssertNoTags()
     {
         if (Tags == 0)
             return;
     
-        string tags = string.Join(", ", Enumerable.Range(0, 4)
-            .Where(i => (Tags & (1 << i)) != 0)
-            .Select(i => TypeNames[i]));
-    
-        Ecs.Error($"Cannot use zero-sized structs as generic type arguments for this struct. Remove the following type arguments: {tags}");
+        Ecs.Error($"Cannot use zero-sized structs as generic type arguments for this struct. Remove the following type arguments: {GetTypeListString(Tags)}");
     }
     
     [Conditional("DEBUG")]
@@ -37,10 +43,20 @@ public static void AssertReferenceTypes(bool allowReferenceTypes)
         if (allowReferenceTypes || ReferenceTypes == 0)
             return;
     
-        string referenceTypes = string.Join(", ", Enumerable.Range(0, 4)
-            .Where(i => (ReferenceTypes & (1 << i)) != 0)
-            .Select(i => TypeNames[i]));
+        Ecs.Error($"Cannot use managed types as generic type arguments for callback signatures that retrieve pointers or spans. Remove the following type arguments: {GetTypeListString(ReferenceTypes)}");
+    }
     
-        Ecs.Error($"Cannot use managed types as generic type arguments for callback signatures that retrieve pointers or spans. Remove the following type arguments: {referenceTypes}");
+    [Conditional("DEBUG")]
+    public static void AssertSparseTypes(ecs_world_t* world, bool allowSparseTypes)
+    {
+        if (allowSparseTypes)
+            return;
+ 
+        int sparseTypes = (ecs_has_id(world, Type<T0>.Id(world), Ecs.Sparse) == Utils.True ? 1 << 0 : 0) | (ecs_has_id(world, Type<T1>.Id(world), Ecs.Sparse) == Utils.True ? 1 << 1 : 0) | (ecs_has_id(world, Type<T2>.Id(world), Ecs.Sparse) == Utils.True ? 1 << 2 : 0) | (ecs_has_id(world, Type<T3>.Id(world), Ecs.Sparse) == Utils.True ? 1 << 3 : 0);
+ 
+        if (sparseTypes == 0)
+            return;
+ 
+        Ecs.Error($"Cannot use sparse components as generic type arguments for this struct when using .Iter() to iterate because sparse fields must be obtained with Iter.FieldAt(). Use .Each()/.Run() to iterate or remove the following types from the list: {GetTypeListString(sparseTypes)}");
     }
 }
\ No newline at end of file
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/TypeHelper/T4.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/TypeHelper/T4.g.cs
index 778c2fcc..c13144a8 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/TypeHelper/T4.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/TypeHelper/T4.g.cs
@@ -6,11 +6,14 @@
 using System.Diagnostics.CodeAnalysis;
 using System.Linq;
 using System.Runtime.CompilerServices;
+using Flecs.NET.Utilities;
+
+using static Flecs.NET.Bindings.flecs;
 
 namespace Flecs.NET.Core;
 
 [SuppressMessage("ReSharper", "StaticMemberInGenericType")]
-internal static partial class TypeHelper<T0, T1, T2, T3, T4>
+internal static unsafe partial class TypeHelper<T0, T1, T2, T3, T4>
 {
     private static string[]? _typeNames;
     public static string[] TypeNames => _typeNames ??= [ Type<T0>.FullName, Type<T1>.FullName, Type<T2>.FullName, Type<T3>.FullName, Type<T4>.FullName ];
@@ -18,17 +21,20 @@ internal static partial class TypeHelper<T0, T1, T2, T3, T4>
     public static readonly int Tags = (Type<T0>.IsTag ? 1 << 0 : 0) | (Type<T1>.IsTag ? 1 << 1 : 0) | (Type<T2>.IsTag ? 1 << 2 : 0) | (Type<T3>.IsTag ? 1 << 3 : 0) | (Type<T4>.IsTag ? 1 << 4 : 0);
     public static readonly int ReferenceTypes = (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() ? 1 << 0 : 0) | (RuntimeHelpers.IsReferenceOrContainsReferences<T1>() ? 1 << 1 : 0) | (RuntimeHelpers.IsReferenceOrContainsReferences<T2>() ? 1 << 2 : 0) | (RuntimeHelpers.IsReferenceOrContainsReferences<T3>() ? 1 << 3 : 0) | (RuntimeHelpers.IsReferenceOrContainsReferences<T4>() ? 1 << 4 : 0);
     
+    private static string GetTypeListString(int fields)
+    {
+        return string.Join(", ", Enumerable.Range(0, 5)
+            .Where(i => (fields & (1 << i)) != 0)
+            .Select(i => TypeNames[i]));
+    }
+    
     [Conditional("DEBUG")]
     public static void AssertNoTags()
     {
         if (Tags == 0)
             return;
     
-        string tags = string.Join(", ", Enumerable.Range(0, 5)
-            .Where(i => (Tags & (1 << i)) != 0)
-            .Select(i => TypeNames[i]));
-    
-        Ecs.Error($"Cannot use zero-sized structs as generic type arguments for this struct. Remove the following type arguments: {tags}");
+        Ecs.Error($"Cannot use zero-sized structs as generic type arguments for this struct. Remove the following type arguments: {GetTypeListString(Tags)}");
     }
     
     [Conditional("DEBUG")]
@@ -37,10 +43,20 @@ public static void AssertReferenceTypes(bool allowReferenceTypes)
         if (allowReferenceTypes || ReferenceTypes == 0)
             return;
     
-        string referenceTypes = string.Join(", ", Enumerable.Range(0, 5)
-            .Where(i => (ReferenceTypes & (1 << i)) != 0)
-            .Select(i => TypeNames[i]));
+        Ecs.Error($"Cannot use managed types as generic type arguments for callback signatures that retrieve pointers or spans. Remove the following type arguments: {GetTypeListString(ReferenceTypes)}");
+    }
     
-        Ecs.Error($"Cannot use managed types as generic type arguments for callback signatures that retrieve pointers or spans. Remove the following type arguments: {referenceTypes}");
+    [Conditional("DEBUG")]
+    public static void AssertSparseTypes(ecs_world_t* world, bool allowSparseTypes)
+    {
+        if (allowSparseTypes)
+            return;
+ 
+        int sparseTypes = (ecs_has_id(world, Type<T0>.Id(world), Ecs.Sparse) == Utils.True ? 1 << 0 : 0) | (ecs_has_id(world, Type<T1>.Id(world), Ecs.Sparse) == Utils.True ? 1 << 1 : 0) | (ecs_has_id(world, Type<T2>.Id(world), Ecs.Sparse) == Utils.True ? 1 << 2 : 0) | (ecs_has_id(world, Type<T3>.Id(world), Ecs.Sparse) == Utils.True ? 1 << 3 : 0) | (ecs_has_id(world, Type<T4>.Id(world), Ecs.Sparse) == Utils.True ? 1 << 4 : 0);
+ 
+        if (sparseTypes == 0)
+            return;
+ 
+        Ecs.Error($"Cannot use sparse components as generic type arguments for this struct when using .Iter() to iterate because sparse fields must be obtained with Iter.FieldAt(). Use .Each()/.Run() to iterate or remove the following types from the list: {GetTypeListString(sparseTypes)}");
     }
 }
\ No newline at end of file
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/TypeHelper/T5.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/TypeHelper/T5.g.cs
index 6b54764c..209649bb 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/TypeHelper/T5.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/TypeHelper/T5.g.cs
@@ -6,11 +6,14 @@
 using System.Diagnostics.CodeAnalysis;
 using System.Linq;
 using System.Runtime.CompilerServices;
+using Flecs.NET.Utilities;
+
+using static Flecs.NET.Bindings.flecs;
 
 namespace Flecs.NET.Core;
 
 [SuppressMessage("ReSharper", "StaticMemberInGenericType")]
-internal static partial class TypeHelper<T0, T1, T2, T3, T4, T5>
+internal static unsafe partial class TypeHelper<T0, T1, T2, T3, T4, T5>
 {
     private static string[]? _typeNames;
     public static string[] TypeNames => _typeNames ??= [ Type<T0>.FullName, Type<T1>.FullName, Type<T2>.FullName, Type<T3>.FullName, Type<T4>.FullName, Type<T5>.FullName ];
@@ -18,17 +21,20 @@ internal static partial class TypeHelper<T0, T1, T2, T3, T4, T5>
     public static readonly int Tags = (Type<T0>.IsTag ? 1 << 0 : 0) | (Type<T1>.IsTag ? 1 << 1 : 0) | (Type<T2>.IsTag ? 1 << 2 : 0) | (Type<T3>.IsTag ? 1 << 3 : 0) | (Type<T4>.IsTag ? 1 << 4 : 0) | (Type<T5>.IsTag ? 1 << 5 : 0);
     public static readonly int ReferenceTypes = (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() ? 1 << 0 : 0) | (RuntimeHelpers.IsReferenceOrContainsReferences<T1>() ? 1 << 1 : 0) | (RuntimeHelpers.IsReferenceOrContainsReferences<T2>() ? 1 << 2 : 0) | (RuntimeHelpers.IsReferenceOrContainsReferences<T3>() ? 1 << 3 : 0) | (RuntimeHelpers.IsReferenceOrContainsReferences<T4>() ? 1 << 4 : 0) | (RuntimeHelpers.IsReferenceOrContainsReferences<T5>() ? 1 << 5 : 0);
     
+    private static string GetTypeListString(int fields)
+    {
+        return string.Join(", ", Enumerable.Range(0, 6)
+            .Where(i => (fields & (1 << i)) != 0)
+            .Select(i => TypeNames[i]));
+    }
+    
     [Conditional("DEBUG")]
     public static void AssertNoTags()
     {
         if (Tags == 0)
             return;
     
-        string tags = string.Join(", ", Enumerable.Range(0, 6)
-            .Where(i => (Tags & (1 << i)) != 0)
-            .Select(i => TypeNames[i]));
-    
-        Ecs.Error($"Cannot use zero-sized structs as generic type arguments for this struct. Remove the following type arguments: {tags}");
+        Ecs.Error($"Cannot use zero-sized structs as generic type arguments for this struct. Remove the following type arguments: {GetTypeListString(Tags)}");
     }
     
     [Conditional("DEBUG")]
@@ -37,10 +43,20 @@ public static void AssertReferenceTypes(bool allowReferenceTypes)
         if (allowReferenceTypes || ReferenceTypes == 0)
             return;
     
-        string referenceTypes = string.Join(", ", Enumerable.Range(0, 6)
-            .Where(i => (ReferenceTypes & (1 << i)) != 0)
-            .Select(i => TypeNames[i]));
+        Ecs.Error($"Cannot use managed types as generic type arguments for callback signatures that retrieve pointers or spans. Remove the following type arguments: {GetTypeListString(ReferenceTypes)}");
+    }
     
-        Ecs.Error($"Cannot use managed types as generic type arguments for callback signatures that retrieve pointers or spans. Remove the following type arguments: {referenceTypes}");
+    [Conditional("DEBUG")]
+    public static void AssertSparseTypes(ecs_world_t* world, bool allowSparseTypes)
+    {
+        if (allowSparseTypes)
+            return;
+ 
+        int sparseTypes = (ecs_has_id(world, Type<T0>.Id(world), Ecs.Sparse) == Utils.True ? 1 << 0 : 0) | (ecs_has_id(world, Type<T1>.Id(world), Ecs.Sparse) == Utils.True ? 1 << 1 : 0) | (ecs_has_id(world, Type<T2>.Id(world), Ecs.Sparse) == Utils.True ? 1 << 2 : 0) | (ecs_has_id(world, Type<T3>.Id(world), Ecs.Sparse) == Utils.True ? 1 << 3 : 0) | (ecs_has_id(world, Type<T4>.Id(world), Ecs.Sparse) == Utils.True ? 1 << 4 : 0) | (ecs_has_id(world, Type<T5>.Id(world), Ecs.Sparse) == Utils.True ? 1 << 5 : 0);
+ 
+        if (sparseTypes == 0)
+            return;
+ 
+        Ecs.Error($"Cannot use sparse components as generic type arguments for this struct when using .Iter() to iterate because sparse fields must be obtained with Iter.FieldAt(). Use .Each()/.Run() to iterate or remove the following types from the list: {GetTypeListString(sparseTypes)}");
     }
 }
\ No newline at end of file
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/TypeHelper/T6.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/TypeHelper/T6.g.cs
index 408769cd..eb423a11 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/TypeHelper/T6.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/TypeHelper/T6.g.cs
@@ -6,11 +6,14 @@
 using System.Diagnostics.CodeAnalysis;
 using System.Linq;
 using System.Runtime.CompilerServices;
+using Flecs.NET.Utilities;
+
+using static Flecs.NET.Bindings.flecs;
 
 namespace Flecs.NET.Core;
 
 [SuppressMessage("ReSharper", "StaticMemberInGenericType")]
-internal static partial class TypeHelper<T0, T1, T2, T3, T4, T5, T6>
+internal static unsafe partial class TypeHelper<T0, T1, T2, T3, T4, T5, T6>
 {
     private static string[]? _typeNames;
     public static string[] TypeNames => _typeNames ??= [ Type<T0>.FullName, Type<T1>.FullName, Type<T2>.FullName, Type<T3>.FullName, Type<T4>.FullName, Type<T5>.FullName, Type<T6>.FullName ];
@@ -18,17 +21,20 @@ internal static partial class TypeHelper<T0, T1, T2, T3, T4, T5, T6>
     public static readonly int Tags = (Type<T0>.IsTag ? 1 << 0 : 0) | (Type<T1>.IsTag ? 1 << 1 : 0) | (Type<T2>.IsTag ? 1 << 2 : 0) | (Type<T3>.IsTag ? 1 << 3 : 0) | (Type<T4>.IsTag ? 1 << 4 : 0) | (Type<T5>.IsTag ? 1 << 5 : 0) | (Type<T6>.IsTag ? 1 << 6 : 0);
     public static readonly int ReferenceTypes = (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() ? 1 << 0 : 0) | (RuntimeHelpers.IsReferenceOrContainsReferences<T1>() ? 1 << 1 : 0) | (RuntimeHelpers.IsReferenceOrContainsReferences<T2>() ? 1 << 2 : 0) | (RuntimeHelpers.IsReferenceOrContainsReferences<T3>() ? 1 << 3 : 0) | (RuntimeHelpers.IsReferenceOrContainsReferences<T4>() ? 1 << 4 : 0) | (RuntimeHelpers.IsReferenceOrContainsReferences<T5>() ? 1 << 5 : 0) | (RuntimeHelpers.IsReferenceOrContainsReferences<T6>() ? 1 << 6 : 0);
     
+    private static string GetTypeListString(int fields)
+    {
+        return string.Join(", ", Enumerable.Range(0, 7)
+            .Where(i => (fields & (1 << i)) != 0)
+            .Select(i => TypeNames[i]));
+    }
+    
     [Conditional("DEBUG")]
     public static void AssertNoTags()
     {
         if (Tags == 0)
             return;
     
-        string tags = string.Join(", ", Enumerable.Range(0, 7)
-            .Where(i => (Tags & (1 << i)) != 0)
-            .Select(i => TypeNames[i]));
-    
-        Ecs.Error($"Cannot use zero-sized structs as generic type arguments for this struct. Remove the following type arguments: {tags}");
+        Ecs.Error($"Cannot use zero-sized structs as generic type arguments for this struct. Remove the following type arguments: {GetTypeListString(Tags)}");
     }
     
     [Conditional("DEBUG")]
@@ -37,10 +43,20 @@ public static void AssertReferenceTypes(bool allowReferenceTypes)
         if (allowReferenceTypes || ReferenceTypes == 0)
             return;
     
-        string referenceTypes = string.Join(", ", Enumerable.Range(0, 7)
-            .Where(i => (ReferenceTypes & (1 << i)) != 0)
-            .Select(i => TypeNames[i]));
+        Ecs.Error($"Cannot use managed types as generic type arguments for callback signatures that retrieve pointers or spans. Remove the following type arguments: {GetTypeListString(ReferenceTypes)}");
+    }
     
-        Ecs.Error($"Cannot use managed types as generic type arguments for callback signatures that retrieve pointers or spans. Remove the following type arguments: {referenceTypes}");
+    [Conditional("DEBUG")]
+    public static void AssertSparseTypes(ecs_world_t* world, bool allowSparseTypes)
+    {
+        if (allowSparseTypes)
+            return;
+ 
+        int sparseTypes = (ecs_has_id(world, Type<T0>.Id(world), Ecs.Sparse) == Utils.True ? 1 << 0 : 0) | (ecs_has_id(world, Type<T1>.Id(world), Ecs.Sparse) == Utils.True ? 1 << 1 : 0) | (ecs_has_id(world, Type<T2>.Id(world), Ecs.Sparse) == Utils.True ? 1 << 2 : 0) | (ecs_has_id(world, Type<T3>.Id(world), Ecs.Sparse) == Utils.True ? 1 << 3 : 0) | (ecs_has_id(world, Type<T4>.Id(world), Ecs.Sparse) == Utils.True ? 1 << 4 : 0) | (ecs_has_id(world, Type<T5>.Id(world), Ecs.Sparse) == Utils.True ? 1 << 5 : 0) | (ecs_has_id(world, Type<T6>.Id(world), Ecs.Sparse) == Utils.True ? 1 << 6 : 0);
+ 
+        if (sparseTypes == 0)
+            return;
+ 
+        Ecs.Error($"Cannot use sparse components as generic type arguments for this struct when using .Iter() to iterate because sparse fields must be obtained with Iter.FieldAt(). Use .Each()/.Run() to iterate or remove the following types from the list: {GetTypeListString(sparseTypes)}");
     }
 }
\ No newline at end of file
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/TypeHelper/T7.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/TypeHelper/T7.g.cs
index 3734d10e..cc617ca2 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/TypeHelper/T7.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/TypeHelper/T7.g.cs
@@ -6,11 +6,14 @@
 using System.Diagnostics.CodeAnalysis;
 using System.Linq;
 using System.Runtime.CompilerServices;
+using Flecs.NET.Utilities;
+
+using static Flecs.NET.Bindings.flecs;
 
 namespace Flecs.NET.Core;
 
 [SuppressMessage("ReSharper", "StaticMemberInGenericType")]
-internal static partial class TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>
+internal static unsafe partial class TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>
 {
     private static string[]? _typeNames;
     public static string[] TypeNames => _typeNames ??= [ Type<T0>.FullName, Type<T1>.FullName, Type<T2>.FullName, Type<T3>.FullName, Type<T4>.FullName, Type<T5>.FullName, Type<T6>.FullName, Type<T7>.FullName ];
@@ -18,17 +21,20 @@ internal static partial class TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>
     public static readonly int Tags = (Type<T0>.IsTag ? 1 << 0 : 0) | (Type<T1>.IsTag ? 1 << 1 : 0) | (Type<T2>.IsTag ? 1 << 2 : 0) | (Type<T3>.IsTag ? 1 << 3 : 0) | (Type<T4>.IsTag ? 1 << 4 : 0) | (Type<T5>.IsTag ? 1 << 5 : 0) | (Type<T6>.IsTag ? 1 << 6 : 0) | (Type<T7>.IsTag ? 1 << 7 : 0);
     public static readonly int ReferenceTypes = (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() ? 1 << 0 : 0) | (RuntimeHelpers.IsReferenceOrContainsReferences<T1>() ? 1 << 1 : 0) | (RuntimeHelpers.IsReferenceOrContainsReferences<T2>() ? 1 << 2 : 0) | (RuntimeHelpers.IsReferenceOrContainsReferences<T3>() ? 1 << 3 : 0) | (RuntimeHelpers.IsReferenceOrContainsReferences<T4>() ? 1 << 4 : 0) | (RuntimeHelpers.IsReferenceOrContainsReferences<T5>() ? 1 << 5 : 0) | (RuntimeHelpers.IsReferenceOrContainsReferences<T6>() ? 1 << 6 : 0) | (RuntimeHelpers.IsReferenceOrContainsReferences<T7>() ? 1 << 7 : 0);
     
+    private static string GetTypeListString(int fields)
+    {
+        return string.Join(", ", Enumerable.Range(0, 8)
+            .Where(i => (fields & (1 << i)) != 0)
+            .Select(i => TypeNames[i]));
+    }
+    
     [Conditional("DEBUG")]
     public static void AssertNoTags()
     {
         if (Tags == 0)
             return;
     
-        string tags = string.Join(", ", Enumerable.Range(0, 8)
-            .Where(i => (Tags & (1 << i)) != 0)
-            .Select(i => TypeNames[i]));
-    
-        Ecs.Error($"Cannot use zero-sized structs as generic type arguments for this struct. Remove the following type arguments: {tags}");
+        Ecs.Error($"Cannot use zero-sized structs as generic type arguments for this struct. Remove the following type arguments: {GetTypeListString(Tags)}");
     }
     
     [Conditional("DEBUG")]
@@ -37,10 +43,20 @@ public static void AssertReferenceTypes(bool allowReferenceTypes)
         if (allowReferenceTypes || ReferenceTypes == 0)
             return;
     
-        string referenceTypes = string.Join(", ", Enumerable.Range(0, 8)
-            .Where(i => (ReferenceTypes & (1 << i)) != 0)
-            .Select(i => TypeNames[i]));
+        Ecs.Error($"Cannot use managed types as generic type arguments for callback signatures that retrieve pointers or spans. Remove the following type arguments: {GetTypeListString(ReferenceTypes)}");
+    }
     
-        Ecs.Error($"Cannot use managed types as generic type arguments for callback signatures that retrieve pointers or spans. Remove the following type arguments: {referenceTypes}");
+    [Conditional("DEBUG")]
+    public static void AssertSparseTypes(ecs_world_t* world, bool allowSparseTypes)
+    {
+        if (allowSparseTypes)
+            return;
+ 
+        int sparseTypes = (ecs_has_id(world, Type<T0>.Id(world), Ecs.Sparse) == Utils.True ? 1 << 0 : 0) | (ecs_has_id(world, Type<T1>.Id(world), Ecs.Sparse) == Utils.True ? 1 << 1 : 0) | (ecs_has_id(world, Type<T2>.Id(world), Ecs.Sparse) == Utils.True ? 1 << 2 : 0) | (ecs_has_id(world, Type<T3>.Id(world), Ecs.Sparse) == Utils.True ? 1 << 3 : 0) | (ecs_has_id(world, Type<T4>.Id(world), Ecs.Sparse) == Utils.True ? 1 << 4 : 0) | (ecs_has_id(world, Type<T5>.Id(world), Ecs.Sparse) == Utils.True ? 1 << 5 : 0) | (ecs_has_id(world, Type<T6>.Id(world), Ecs.Sparse) == Utils.True ? 1 << 6 : 0) | (ecs_has_id(world, Type<T7>.Id(world), Ecs.Sparse) == Utils.True ? 1 << 7 : 0);
+ 
+        if (sparseTypes == 0)
+            return;
+ 
+        Ecs.Error($"Cannot use sparse components as generic type arguments for this struct when using .Iter() to iterate because sparse fields must be obtained with Iter.FieldAt(). Use .Each()/.Run() to iterate or remove the following types from the list: {GetTypeListString(sparseTypes)}");
     }
 }
\ No newline at end of file
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/TypeHelper/T8.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/TypeHelper/T8.g.cs
index e888bc33..02fd1666 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/TypeHelper/T8.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/TypeHelper/T8.g.cs
@@ -6,11 +6,14 @@
 using System.Diagnostics.CodeAnalysis;
 using System.Linq;
 using System.Runtime.CompilerServices;
+using Flecs.NET.Utilities;
+
+using static Flecs.NET.Bindings.flecs;
 
 namespace Flecs.NET.Core;
 
 [SuppressMessage("ReSharper", "StaticMemberInGenericType")]
-internal static partial class TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>
+internal static unsafe partial class TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>
 {
     private static string[]? _typeNames;
     public static string[] TypeNames => _typeNames ??= [ Type<T0>.FullName, Type<T1>.FullName, Type<T2>.FullName, Type<T3>.FullName, Type<T4>.FullName, Type<T5>.FullName, Type<T6>.FullName, Type<T7>.FullName, Type<T8>.FullName ];
@@ -18,17 +21,20 @@ internal static partial class TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>
     public static readonly int Tags = (Type<T0>.IsTag ? 1 << 0 : 0) | (Type<T1>.IsTag ? 1 << 1 : 0) | (Type<T2>.IsTag ? 1 << 2 : 0) | (Type<T3>.IsTag ? 1 << 3 : 0) | (Type<T4>.IsTag ? 1 << 4 : 0) | (Type<T5>.IsTag ? 1 << 5 : 0) | (Type<T6>.IsTag ? 1 << 6 : 0) | (Type<T7>.IsTag ? 1 << 7 : 0) | (Type<T8>.IsTag ? 1 << 8 : 0);
     public static readonly int ReferenceTypes = (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() ? 1 << 0 : 0) | (RuntimeHelpers.IsReferenceOrContainsReferences<T1>() ? 1 << 1 : 0) | (RuntimeHelpers.IsReferenceOrContainsReferences<T2>() ? 1 << 2 : 0) | (RuntimeHelpers.IsReferenceOrContainsReferences<T3>() ? 1 << 3 : 0) | (RuntimeHelpers.IsReferenceOrContainsReferences<T4>() ? 1 << 4 : 0) | (RuntimeHelpers.IsReferenceOrContainsReferences<T5>() ? 1 << 5 : 0) | (RuntimeHelpers.IsReferenceOrContainsReferences<T6>() ? 1 << 6 : 0) | (RuntimeHelpers.IsReferenceOrContainsReferences<T7>() ? 1 << 7 : 0) | (RuntimeHelpers.IsReferenceOrContainsReferences<T8>() ? 1 << 8 : 0);
     
+    private static string GetTypeListString(int fields)
+    {
+        return string.Join(", ", Enumerable.Range(0, 9)
+            .Where(i => (fields & (1 << i)) != 0)
+            .Select(i => TypeNames[i]));
+    }
+    
     [Conditional("DEBUG")]
     public static void AssertNoTags()
     {
         if (Tags == 0)
             return;
     
-        string tags = string.Join(", ", Enumerable.Range(0, 9)
-            .Where(i => (Tags & (1 << i)) != 0)
-            .Select(i => TypeNames[i]));
-    
-        Ecs.Error($"Cannot use zero-sized structs as generic type arguments for this struct. Remove the following type arguments: {tags}");
+        Ecs.Error($"Cannot use zero-sized structs as generic type arguments for this struct. Remove the following type arguments: {GetTypeListString(Tags)}");
     }
     
     [Conditional("DEBUG")]
@@ -37,10 +43,20 @@ public static void AssertReferenceTypes(bool allowReferenceTypes)
         if (allowReferenceTypes || ReferenceTypes == 0)
             return;
     
-        string referenceTypes = string.Join(", ", Enumerable.Range(0, 9)
-            .Where(i => (ReferenceTypes & (1 << i)) != 0)
-            .Select(i => TypeNames[i]));
+        Ecs.Error($"Cannot use managed types as generic type arguments for callback signatures that retrieve pointers or spans. Remove the following type arguments: {GetTypeListString(ReferenceTypes)}");
+    }
     
-        Ecs.Error($"Cannot use managed types as generic type arguments for callback signatures that retrieve pointers or spans. Remove the following type arguments: {referenceTypes}");
+    [Conditional("DEBUG")]
+    public static void AssertSparseTypes(ecs_world_t* world, bool allowSparseTypes)
+    {
+        if (allowSparseTypes)
+            return;
+ 
+        int sparseTypes = (ecs_has_id(world, Type<T0>.Id(world), Ecs.Sparse) == Utils.True ? 1 << 0 : 0) | (ecs_has_id(world, Type<T1>.Id(world), Ecs.Sparse) == Utils.True ? 1 << 1 : 0) | (ecs_has_id(world, Type<T2>.Id(world), Ecs.Sparse) == Utils.True ? 1 << 2 : 0) | (ecs_has_id(world, Type<T3>.Id(world), Ecs.Sparse) == Utils.True ? 1 << 3 : 0) | (ecs_has_id(world, Type<T4>.Id(world), Ecs.Sparse) == Utils.True ? 1 << 4 : 0) | (ecs_has_id(world, Type<T5>.Id(world), Ecs.Sparse) == Utils.True ? 1 << 5 : 0) | (ecs_has_id(world, Type<T6>.Id(world), Ecs.Sparse) == Utils.True ? 1 << 6 : 0) | (ecs_has_id(world, Type<T7>.Id(world), Ecs.Sparse) == Utils.True ? 1 << 7 : 0) | (ecs_has_id(world, Type<T8>.Id(world), Ecs.Sparse) == Utils.True ? 1 << 8 : 0);
+ 
+        if (sparseTypes == 0)
+            return;
+ 
+        Ecs.Error($"Cannot use sparse components as generic type arguments for this struct when using .Iter() to iterate because sparse fields must be obtained with Iter.FieldAt(). Use .Each()/.Run() to iterate or remove the following types from the list: {GetTypeListString(sparseTypes)}");
     }
 }
\ No newline at end of file
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/TypeHelper/T9.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/TypeHelper/T9.g.cs
index 02e309e1..7a7d4585 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/TypeHelper/T9.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/TypeHelper/T9.g.cs
@@ -6,11 +6,14 @@
 using System.Diagnostics.CodeAnalysis;
 using System.Linq;
 using System.Runtime.CompilerServices;
+using Flecs.NET.Utilities;
+
+using static Flecs.NET.Bindings.flecs;
 
 namespace Flecs.NET.Core;
 
 [SuppressMessage("ReSharper", "StaticMemberInGenericType")]
-internal static partial class TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>
+internal static unsafe partial class TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>
 {
     private static string[]? _typeNames;
     public static string[] TypeNames => _typeNames ??= [ Type<T0>.FullName, Type<T1>.FullName, Type<T2>.FullName, Type<T3>.FullName, Type<T4>.FullName, Type<T5>.FullName, Type<T6>.FullName, Type<T7>.FullName, Type<T8>.FullName, Type<T9>.FullName ];
@@ -18,17 +21,20 @@ internal static partial class TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>
     public static readonly int Tags = (Type<T0>.IsTag ? 1 << 0 : 0) | (Type<T1>.IsTag ? 1 << 1 : 0) | (Type<T2>.IsTag ? 1 << 2 : 0) | (Type<T3>.IsTag ? 1 << 3 : 0) | (Type<T4>.IsTag ? 1 << 4 : 0) | (Type<T5>.IsTag ? 1 << 5 : 0) | (Type<T6>.IsTag ? 1 << 6 : 0) | (Type<T7>.IsTag ? 1 << 7 : 0) | (Type<T8>.IsTag ? 1 << 8 : 0) | (Type<T9>.IsTag ? 1 << 9 : 0);
     public static readonly int ReferenceTypes = (RuntimeHelpers.IsReferenceOrContainsReferences<T0>() ? 1 << 0 : 0) | (RuntimeHelpers.IsReferenceOrContainsReferences<T1>() ? 1 << 1 : 0) | (RuntimeHelpers.IsReferenceOrContainsReferences<T2>() ? 1 << 2 : 0) | (RuntimeHelpers.IsReferenceOrContainsReferences<T3>() ? 1 << 3 : 0) | (RuntimeHelpers.IsReferenceOrContainsReferences<T4>() ? 1 << 4 : 0) | (RuntimeHelpers.IsReferenceOrContainsReferences<T5>() ? 1 << 5 : 0) | (RuntimeHelpers.IsReferenceOrContainsReferences<T6>() ? 1 << 6 : 0) | (RuntimeHelpers.IsReferenceOrContainsReferences<T7>() ? 1 << 7 : 0) | (RuntimeHelpers.IsReferenceOrContainsReferences<T8>() ? 1 << 8 : 0) | (RuntimeHelpers.IsReferenceOrContainsReferences<T9>() ? 1 << 9 : 0);
     
+    private static string GetTypeListString(int fields)
+    {
+        return string.Join(", ", Enumerable.Range(0, 10)
+            .Where(i => (fields & (1 << i)) != 0)
+            .Select(i => TypeNames[i]));
+    }
+    
     [Conditional("DEBUG")]
     public static void AssertNoTags()
     {
         if (Tags == 0)
             return;
     
-        string tags = string.Join(", ", Enumerable.Range(0, 10)
-            .Where(i => (Tags & (1 << i)) != 0)
-            .Select(i => TypeNames[i]));
-    
-        Ecs.Error($"Cannot use zero-sized structs as generic type arguments for this struct. Remove the following type arguments: {tags}");
+        Ecs.Error($"Cannot use zero-sized structs as generic type arguments for this struct. Remove the following type arguments: {GetTypeListString(Tags)}");
     }
     
     [Conditional("DEBUG")]
@@ -37,10 +43,20 @@ public static void AssertReferenceTypes(bool allowReferenceTypes)
         if (allowReferenceTypes || ReferenceTypes == 0)
             return;
     
-        string referenceTypes = string.Join(", ", Enumerable.Range(0, 10)
-            .Where(i => (ReferenceTypes & (1 << i)) != 0)
-            .Select(i => TypeNames[i]));
+        Ecs.Error($"Cannot use managed types as generic type arguments for callback signatures that retrieve pointers or spans. Remove the following type arguments: {GetTypeListString(ReferenceTypes)}");
+    }
     
-        Ecs.Error($"Cannot use managed types as generic type arguments for callback signatures that retrieve pointers or spans. Remove the following type arguments: {referenceTypes}");
+    [Conditional("DEBUG")]
+    public static void AssertSparseTypes(ecs_world_t* world, bool allowSparseTypes)
+    {
+        if (allowSparseTypes)
+            return;
+ 
+        int sparseTypes = (ecs_has_id(world, Type<T0>.Id(world), Ecs.Sparse) == Utils.True ? 1 << 0 : 0) | (ecs_has_id(world, Type<T1>.Id(world), Ecs.Sparse) == Utils.True ? 1 << 1 : 0) | (ecs_has_id(world, Type<T2>.Id(world), Ecs.Sparse) == Utils.True ? 1 << 2 : 0) | (ecs_has_id(world, Type<T3>.Id(world), Ecs.Sparse) == Utils.True ? 1 << 3 : 0) | (ecs_has_id(world, Type<T4>.Id(world), Ecs.Sparse) == Utils.True ? 1 << 4 : 0) | (ecs_has_id(world, Type<T5>.Id(world), Ecs.Sparse) == Utils.True ? 1 << 5 : 0) | (ecs_has_id(world, Type<T6>.Id(world), Ecs.Sparse) == Utils.True ? 1 << 6 : 0) | (ecs_has_id(world, Type<T7>.Id(world), Ecs.Sparse) == Utils.True ? 1 << 7 : 0) | (ecs_has_id(world, Type<T8>.Id(world), Ecs.Sparse) == Utils.True ? 1 << 8 : 0) | (ecs_has_id(world, Type<T9>.Id(world), Ecs.Sparse) == Utils.True ? 1 << 9 : 0);
+ 
+        if (sparseTypes == 0)
+            return;
+ 
+        Ecs.Error($"Cannot use sparse components as generic type arguments for this struct when using .Iter() to iterate because sparse fields must be obtained with Iter.FieldAt(). Use .Each()/.Run() to iterate or remove the following types from the list: {GetTypeListString(sparseTypes)}");
     }
 }
\ No newline at end of file
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/WorkerIterable/WorkerIterable.IIterable/T1.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/WorkerIterable/WorkerIterable.IIterable/T1.g.cs
index db2147f7..f2d34ed0 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/WorkerIterable/WorkerIterable.IIterable/T1.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/WorkerIterable/WorkerIterable.IIterable/T1.g.cs
@@ -13,6 +13,7 @@ public unsafe partial struct WorkerIterable<T0>
     public void Run(Ecs.RunCallback callback)
     {
         TypeHelper<T0>.AssertReferenceTypes(true);
+        TypeHelper<T0>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Run(ref this, callback);
     }
 
@@ -23,6 +24,7 @@ public void Run(Ecs.RunCallback callback)
     public void Run(delegate*<Iter, void> callback)
     {
         TypeHelper<T0>.AssertReferenceTypes(true);
+        TypeHelper<T0>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Run(ref this, callback);
     }
 
@@ -33,6 +35,7 @@ public void Run(delegate*<Iter, void> callback)
     public void Iter(Ecs.IterFieldCallback<T0> callback)
     {
         TypeHelper<T0>.AssertReferenceTypes(true);
+        TypeHelper<T0>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -43,6 +46,7 @@ public void Iter(Ecs.IterFieldCallback<T0> callback)
     public void Iter(Ecs.IterSpanCallback<T0> callback)
     {
         TypeHelper<T0>.AssertReferenceTypes(false);
+        TypeHelper<T0>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -53,6 +57,7 @@ public void Iter(Ecs.IterSpanCallback<T0> callback)
     public void Iter(Ecs.IterPointerCallback<T0> callback)
     {
         TypeHelper<T0>.AssertReferenceTypes(false);
+        TypeHelper<T0>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -63,6 +68,7 @@ public void Iter(Ecs.IterPointerCallback<T0> callback)
     public void Iter(delegate*<Iter, Field<T0>, void> callback)
     {
         TypeHelper<T0>.AssertReferenceTypes(true);
+        TypeHelper<T0>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -73,6 +79,7 @@ public void Iter(delegate*<Iter, Field<T0>, void> callback)
     public void Iter(delegate*<Iter, Span<T0>, void> callback)
     {
         TypeHelper<T0>.AssertReferenceTypes(false);
+        TypeHelper<T0>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -83,6 +90,7 @@ public void Iter(delegate*<Iter, Span<T0>, void> callback)
     public void Iter(delegate*<Iter, T0*, void> callback)
     {
         TypeHelper<T0>.AssertReferenceTypes(false);
+        TypeHelper<T0>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -93,6 +101,7 @@ public void Iter(delegate*<Iter, T0*, void> callback)
     public void Each(Ecs.EachRefCallback<T0> callback)
     {
         TypeHelper<T0>.AssertReferenceTypes(true);
+        TypeHelper<T0>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -103,6 +112,7 @@ public void Each(Ecs.EachRefCallback<T0> callback)
     public void Each(Ecs.EachEntityRefCallback<T0> callback)
     {
         TypeHelper<T0>.AssertReferenceTypes(true);
+        TypeHelper<T0>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -113,6 +123,7 @@ public void Each(Ecs.EachEntityRefCallback<T0> callback)
     public void Each(Ecs.EachIterRefCallback<T0> callback)
     {
         TypeHelper<T0>.AssertReferenceTypes(true);
+        TypeHelper<T0>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -123,6 +134,7 @@ public void Each(Ecs.EachIterRefCallback<T0> callback)
     public void Each(delegate*<ref T0, void> callback)
     {
         TypeHelper<T0>.AssertReferenceTypes(true);
+        TypeHelper<T0>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -133,6 +145,7 @@ public void Each(delegate*<ref T0, void> callback)
     public void Each(delegate*<Entity, ref T0, void> callback)
     {
         TypeHelper<T0>.AssertReferenceTypes(true);
+        TypeHelper<T0>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -143,6 +156,7 @@ public void Each(delegate*<Entity, ref T0, void> callback)
     public void Each(delegate*<Iter, int, ref T0, void> callback)
     {
         TypeHelper<T0>.AssertReferenceTypes(true);
+        TypeHelper<T0>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -153,6 +167,7 @@ public void Each(delegate*<Iter, int, ref T0, void> callback)
     public void Each(Ecs.EachPointerCallback<T0> callback)
     {
         TypeHelper<T0>.AssertReferenceTypes(false);
+        TypeHelper<T0>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -163,6 +178,7 @@ public void Each(Ecs.EachPointerCallback<T0> callback)
     public void Each(Ecs.EachEntityPointerCallback<T0> callback)
     {
         TypeHelper<T0>.AssertReferenceTypes(false);
+        TypeHelper<T0>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -173,6 +189,7 @@ public void Each(Ecs.EachEntityPointerCallback<T0> callback)
     public void Each(Ecs.EachIterPointerCallback<T0> callback)
     {
         TypeHelper<T0>.AssertReferenceTypes(false);
+        TypeHelper<T0>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -183,6 +200,7 @@ public void Each(Ecs.EachIterPointerCallback<T0> callback)
     public void Each(delegate*<T0*, void> callback)
     {
         TypeHelper<T0>.AssertReferenceTypes(false);
+        TypeHelper<T0>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -193,6 +211,7 @@ public void Each(delegate*<T0*, void> callback)
     public void Each(delegate*<Entity, T0*, void> callback)
     {
         TypeHelper<T0>.AssertReferenceTypes(false);
+        TypeHelper<T0>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -203,6 +222,7 @@ public void Each(delegate*<Entity, T0*, void> callback)
     public void Each(delegate*<Iter, int, T0*, void> callback)
     {
         TypeHelper<T0>.AssertReferenceTypes(false);
+        TypeHelper<T0>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -213,6 +233,7 @@ public void Each(delegate*<Iter, int, T0*, void> callback)
     public Entity Find(Ecs.FindRefCallback<T0> callback)
     {
         TypeHelper<T0>.AssertReferenceTypes(true);
+        TypeHelper<T0>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -223,6 +244,7 @@ public Entity Find(Ecs.FindRefCallback<T0> callback)
     public Entity Find(Ecs.FindEntityRefCallback<T0> callback)
     {
         TypeHelper<T0>.AssertReferenceTypes(true);
+        TypeHelper<T0>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -233,6 +255,7 @@ public Entity Find(Ecs.FindEntityRefCallback<T0> callback)
     public Entity Find(Ecs.FindIterRefCallback<T0> callback)
     {
         TypeHelper<T0>.AssertReferenceTypes(true);
+        TypeHelper<T0>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -243,6 +266,7 @@ public Entity Find(Ecs.FindIterRefCallback<T0> callback)
     public Entity Find(delegate*<ref T0, bool> callback)
     {
         TypeHelper<T0>.AssertReferenceTypes(true);
+        TypeHelper<T0>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -253,6 +277,7 @@ public Entity Find(delegate*<ref T0, bool> callback)
     public Entity Find(delegate*<Entity, ref T0, bool> callback)
     {
         TypeHelper<T0>.AssertReferenceTypes(true);
+        TypeHelper<T0>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -263,6 +288,7 @@ public Entity Find(delegate*<Entity, ref T0, bool> callback)
     public Entity Find(delegate*<Iter, int, ref T0, bool> callback)
     {
         TypeHelper<T0>.AssertReferenceTypes(true);
+        TypeHelper<T0>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -273,6 +299,7 @@ public Entity Find(delegate*<Iter, int, ref T0, bool> callback)
     public Entity Find(Ecs.FindPointerCallback<T0> callback)
     {
         TypeHelper<T0>.AssertReferenceTypes(false);
+        TypeHelper<T0>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -283,6 +310,7 @@ public Entity Find(Ecs.FindPointerCallback<T0> callback)
     public Entity Find(Ecs.FindEntityPointerCallback<T0> callback)
     {
         TypeHelper<T0>.AssertReferenceTypes(false);
+        TypeHelper<T0>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -293,6 +321,7 @@ public Entity Find(Ecs.FindEntityPointerCallback<T0> callback)
     public Entity Find(Ecs.FindIterPointerCallback<T0> callback)
     {
         TypeHelper<T0>.AssertReferenceTypes(false);
+        TypeHelper<T0>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -303,6 +332,7 @@ public Entity Find(Ecs.FindIterPointerCallback<T0> callback)
     public Entity Find(delegate*<T0*, bool> callback)
     {
         TypeHelper<T0>.AssertReferenceTypes(false);
+        TypeHelper<T0>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -313,6 +343,7 @@ public Entity Find(delegate*<T0*, bool> callback)
     public Entity Find(delegate*<Entity, T0*, bool> callback)
     {
         TypeHelper<T0>.AssertReferenceTypes(false);
+        TypeHelper<T0>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -323,6 +354,7 @@ public Entity Find(delegate*<Entity, T0*, bool> callback)
     public Entity Find(delegate*<Iter, int, T0*, bool> callback)
     {
         TypeHelper<T0>.AssertReferenceTypes(false);
+        TypeHelper<T0>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 }
\ No newline at end of file
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/WorkerIterable/WorkerIterable.IIterable/T10.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/WorkerIterable/WorkerIterable.IIterable/T10.g.cs
index d20d5d7a..f991fa2f 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/WorkerIterable/WorkerIterable.IIterable/T10.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/WorkerIterable/WorkerIterable.IIterable/T10.g.cs
@@ -13,6 +13,7 @@ public unsafe partial struct WorkerIterable<T0, T1, T2, T3, T4, T5, T6, T7, T8,
     public void Run(Ecs.RunCallback callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Run(ref this, callback);
     }
 
@@ -23,6 +24,7 @@ public void Run(Ecs.RunCallback callback)
     public void Run(delegate*<Iter, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Run(ref this, callback);
     }
 
@@ -33,6 +35,7 @@ public void Run(delegate*<Iter, void> callback)
     public void Iter(Ecs.IterFieldCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -43,6 +46,7 @@ public void Iter(Ecs.IterFieldCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> c
     public void Iter(Ecs.IterSpanCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -53,6 +57,7 @@ public void Iter(Ecs.IterSpanCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> ca
     public void Iter(Ecs.IterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -63,6 +68,7 @@ public void Iter(Ecs.IterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>
     public void Iter(delegate*<Iter, Field<T0>, Field<T1>, Field<T2>, Field<T3>, Field<T4>, Field<T5>, Field<T6>, Field<T7>, Field<T8>, Field<T9>, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -73,6 +79,7 @@ public void Iter(delegate*<Iter, Field<T0>, Field<T1>, Field<T2>, Field<T3>, Fie
     public void Iter(delegate*<Iter, Span<T0>, Span<T1>, Span<T2>, Span<T3>, Span<T4>, Span<T5>, Span<T6>, Span<T7>, Span<T8>, Span<T9>, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -83,6 +90,7 @@ public void Iter(delegate*<Iter, Span<T0>, Span<T1>, Span<T2>, Span<T3>, Span<T4
     public void Iter(delegate*<Iter, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -93,6 +101,7 @@ public void Iter(delegate*<Iter, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9
     public void Each(Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -103,6 +112,7 @@ public void Each(Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> cal
     public void Each(Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -113,6 +123,7 @@ public void Each(Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T
     public void Each(Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -123,6 +134,7 @@ public void Each(Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>
     public void Each(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -133,6 +145,7 @@ public void Each(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T
     public void Each(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -143,6 +156,7 @@ public void Each(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T
     public void Each(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -153,6 +167,7 @@ public void Each(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, re
     public void Each(Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -163,6 +178,7 @@ public void Each(Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>
     public void Each(Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -173,6 +189,7 @@ public void Each(Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T
     public void Each(Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -183,6 +200,7 @@ public void Each(Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8,
     public void Each(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -193,6 +211,7 @@ public void Each(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, voi
     public void Each(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -203,6 +222,7 @@ public void Each(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*,
     public void Each(delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -213,6 +233,7 @@ public void Each(delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8
     public Entity Find(Ecs.FindRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -223,6 +244,7 @@ public Entity Find(Ecs.FindRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> c
     public Entity Find(Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -233,6 +255,7 @@ public Entity Find(Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8,
     public Entity Find(Ecs.FindIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -243,6 +266,7 @@ public Entity Find(Ecs.FindIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T
     public Entity Find(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -253,6 +277,7 @@ public Entity Find(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref
     public Entity Find(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -263,6 +288,7 @@ public Entity Find(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref
     public Entity Find(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -273,6 +299,7 @@ public Entity Find(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4,
     public Entity Find(Ecs.FindPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -283,6 +310,7 @@ public Entity Find(Ecs.FindPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T
     public Entity Find(Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -293,6 +321,7 @@ public Entity Find(Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7,
     public Entity Find(Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -303,6 +332,7 @@ public Entity Find(Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T
     public Entity Find(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -313,6 +343,7 @@ public Entity Find(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, b
     public Entity Find(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -323,6 +354,7 @@ public Entity Find(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*
     public Entity Find(delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 }
\ No newline at end of file
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/WorkerIterable/WorkerIterable.IIterable/T11.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/WorkerIterable/WorkerIterable.IIterable/T11.g.cs
index 1122462a..78ebdc33 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/WorkerIterable/WorkerIterable.IIterable/T11.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/WorkerIterable/WorkerIterable.IIterable/T11.g.cs
@@ -13,6 +13,7 @@ public unsafe partial struct WorkerIterable<T0, T1, T2, T3, T4, T5, T6, T7, T8,
     public void Run(Ecs.RunCallback callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Run(ref this, callback);
     }
 
@@ -23,6 +24,7 @@ public void Run(Ecs.RunCallback callback)
     public void Run(delegate*<Iter, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Run(ref this, callback);
     }
 
@@ -33,6 +35,7 @@ public void Run(delegate*<Iter, void> callback)
     public void Iter(Ecs.IterFieldCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -43,6 +46,7 @@ public void Iter(Ecs.IterFieldCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T
     public void Iter(Ecs.IterSpanCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -53,6 +57,7 @@ public void Iter(Ecs.IterSpanCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T1
     public void Iter(Ecs.IterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -63,6 +68,7 @@ public void Iter(Ecs.IterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9,
     public void Iter(delegate*<Iter, Field<T0>, Field<T1>, Field<T2>, Field<T3>, Field<T4>, Field<T5>, Field<T6>, Field<T7>, Field<T8>, Field<T9>, Field<T10>, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -73,6 +79,7 @@ public void Iter(delegate*<Iter, Field<T0>, Field<T1>, Field<T2>, Field<T3>, Fie
     public void Iter(delegate*<Iter, Span<T0>, Span<T1>, Span<T2>, Span<T3>, Span<T4>, Span<T5>, Span<T6>, Span<T7>, Span<T8>, Span<T9>, Span<T10>, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -83,6 +90,7 @@ public void Iter(delegate*<Iter, Span<T0>, Span<T1>, Span<T2>, Span<T3>, Span<T4
     public void Iter(delegate*<Iter, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -93,6 +101,7 @@ public void Iter(delegate*<Iter, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9
     public void Each(Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -103,6 +112,7 @@ public void Each(Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10
     public void Each(Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -113,6 +123,7 @@ public void Each(Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T
     public void Each(Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -123,6 +134,7 @@ public void Each(Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9,
     public void Each(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -133,6 +145,7 @@ public void Each(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T
     public void Each(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -143,6 +156,7 @@ public void Each(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T
     public void Each(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -153,6 +167,7 @@ public void Each(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, re
     public void Each(Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -163,6 +178,7 @@ public void Each(Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9,
     public void Each(Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -173,6 +189,7 @@ public void Each(Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T
     public void Each(Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -183,6 +200,7 @@ public void Each(Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8,
     public void Each(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -193,6 +211,7 @@ public void Each(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10
     public void Each(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -203,6 +222,7 @@ public void Each(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*,
     public void Each(delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -213,6 +233,7 @@ public void Each(delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8
     public Entity Find(Ecs.FindRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -223,6 +244,7 @@ public Entity Find(Ecs.FindRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T
     public Entity Find(Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -233,6 +255,7 @@ public Entity Find(Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8,
     public Entity Find(Ecs.FindIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -243,6 +266,7 @@ public Entity Find(Ecs.FindIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T
     public Entity Find(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -253,6 +277,7 @@ public Entity Find(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref
     public Entity Find(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -263,6 +288,7 @@ public Entity Find(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref
     public Entity Find(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -273,6 +299,7 @@ public Entity Find(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4,
     public Entity Find(Ecs.FindPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -283,6 +310,7 @@ public Entity Find(Ecs.FindPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T
     public Entity Find(Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -293,6 +321,7 @@ public Entity Find(Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7,
     public Entity Find(Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -303,6 +332,7 @@ public Entity Find(Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T
     public Entity Find(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -313,6 +343,7 @@ public Entity Find(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T
     public Entity Find(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -323,6 +354,7 @@ public Entity Find(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*
     public Entity Find(delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 }
\ No newline at end of file
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/WorkerIterable/WorkerIterable.IIterable/T12.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/WorkerIterable/WorkerIterable.IIterable/T12.g.cs
index bdfd3d4f..d4beb7d3 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/WorkerIterable/WorkerIterable.IIterable/T12.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/WorkerIterable/WorkerIterable.IIterable/T12.g.cs
@@ -13,6 +13,7 @@ public unsafe partial struct WorkerIterable<T0, T1, T2, T3, T4, T5, T6, T7, T8,
     public void Run(Ecs.RunCallback callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Run(ref this, callback);
     }
 
@@ -23,6 +24,7 @@ public void Run(Ecs.RunCallback callback)
     public void Run(delegate*<Iter, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Run(ref this, callback);
     }
 
@@ -33,6 +35,7 @@ public void Run(delegate*<Iter, void> callback)
     public void Iter(Ecs.IterFieldCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -43,6 +46,7 @@ public void Iter(Ecs.IterFieldCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T
     public void Iter(Ecs.IterSpanCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -53,6 +57,7 @@ public void Iter(Ecs.IterSpanCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T1
     public void Iter(Ecs.IterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -63,6 +68,7 @@ public void Iter(Ecs.IterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9,
     public void Iter(delegate*<Iter, Field<T0>, Field<T1>, Field<T2>, Field<T3>, Field<T4>, Field<T5>, Field<T6>, Field<T7>, Field<T8>, Field<T9>, Field<T10>, Field<T11>, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -73,6 +79,7 @@ public void Iter(delegate*<Iter, Field<T0>, Field<T1>, Field<T2>, Field<T3>, Fie
     public void Iter(delegate*<Iter, Span<T0>, Span<T1>, Span<T2>, Span<T3>, Span<T4>, Span<T5>, Span<T6>, Span<T7>, Span<T8>, Span<T9>, Span<T10>, Span<T11>, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -83,6 +90,7 @@ public void Iter(delegate*<Iter, Span<T0>, Span<T1>, Span<T2>, Span<T3>, Span<T4
     public void Iter(delegate*<Iter, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -93,6 +101,7 @@ public void Iter(delegate*<Iter, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9
     public void Each(Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -103,6 +112,7 @@ public void Each(Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10
     public void Each(Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -113,6 +123,7 @@ public void Each(Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T
     public void Each(Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -123,6 +134,7 @@ public void Each(Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9,
     public void Each(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -133,6 +145,7 @@ public void Each(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T
     public void Each(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -143,6 +156,7 @@ public void Each(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T
     public void Each(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -153,6 +167,7 @@ public void Each(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, re
     public void Each(Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -163,6 +178,7 @@ public void Each(Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9,
     public void Each(Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -173,6 +189,7 @@ public void Each(Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T
     public void Each(Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -183,6 +200,7 @@ public void Each(Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8,
     public void Each(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -193,6 +211,7 @@ public void Each(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10
     public void Each(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -203,6 +222,7 @@ public void Each(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*,
     public void Each(delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -213,6 +233,7 @@ public void Each(delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8
     public Entity Find(Ecs.FindRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -223,6 +244,7 @@ public Entity Find(Ecs.FindRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T
     public Entity Find(Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -233,6 +255,7 @@ public Entity Find(Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8,
     public Entity Find(Ecs.FindIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -243,6 +266,7 @@ public Entity Find(Ecs.FindIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T
     public Entity Find(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -253,6 +277,7 @@ public Entity Find(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref
     public Entity Find(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -263,6 +288,7 @@ public Entity Find(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref
     public Entity Find(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -273,6 +299,7 @@ public Entity Find(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4,
     public Entity Find(Ecs.FindPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -283,6 +310,7 @@ public Entity Find(Ecs.FindPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T
     public Entity Find(Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -293,6 +321,7 @@ public Entity Find(Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7,
     public Entity Find(Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -303,6 +332,7 @@ public Entity Find(Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T
     public Entity Find(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -313,6 +343,7 @@ public Entity Find(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T
     public Entity Find(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -323,6 +354,7 @@ public Entity Find(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*
     public Entity Find(delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 }
\ No newline at end of file
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/WorkerIterable/WorkerIterable.IIterable/T13.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/WorkerIterable/WorkerIterable.IIterable/T13.g.cs
index bfb9c3e9..6c3359b9 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/WorkerIterable/WorkerIterable.IIterable/T13.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/WorkerIterable/WorkerIterable.IIterable/T13.g.cs
@@ -13,6 +13,7 @@ public unsafe partial struct WorkerIterable<T0, T1, T2, T3, T4, T5, T6, T7, T8,
     public void Run(Ecs.RunCallback callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Run(ref this, callback);
     }
 
@@ -23,6 +24,7 @@ public void Run(Ecs.RunCallback callback)
     public void Run(delegate*<Iter, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Run(ref this, callback);
     }
 
@@ -33,6 +35,7 @@ public void Run(delegate*<Iter, void> callback)
     public void Iter(Ecs.IterFieldCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -43,6 +46,7 @@ public void Iter(Ecs.IterFieldCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T
     public void Iter(Ecs.IterSpanCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -53,6 +57,7 @@ public void Iter(Ecs.IterSpanCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T1
     public void Iter(Ecs.IterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -63,6 +68,7 @@ public void Iter(Ecs.IterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9,
     public void Iter(delegate*<Iter, Field<T0>, Field<T1>, Field<T2>, Field<T3>, Field<T4>, Field<T5>, Field<T6>, Field<T7>, Field<T8>, Field<T9>, Field<T10>, Field<T11>, Field<T12>, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -73,6 +79,7 @@ public void Iter(delegate*<Iter, Field<T0>, Field<T1>, Field<T2>, Field<T3>, Fie
     public void Iter(delegate*<Iter, Span<T0>, Span<T1>, Span<T2>, Span<T3>, Span<T4>, Span<T5>, Span<T6>, Span<T7>, Span<T8>, Span<T9>, Span<T10>, Span<T11>, Span<T12>, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -83,6 +90,7 @@ public void Iter(delegate*<Iter, Span<T0>, Span<T1>, Span<T2>, Span<T3>, Span<T4
     public void Iter(delegate*<Iter, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -93,6 +101,7 @@ public void Iter(delegate*<Iter, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9
     public void Each(Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -103,6 +112,7 @@ public void Each(Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10
     public void Each(Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -113,6 +123,7 @@ public void Each(Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T
     public void Each(Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -123,6 +134,7 @@ public void Each(Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9,
     public void Each(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -133,6 +145,7 @@ public void Each(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T
     public void Each(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -143,6 +156,7 @@ public void Each(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T
     public void Each(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -153,6 +167,7 @@ public void Each(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, re
     public void Each(Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -163,6 +178,7 @@ public void Each(Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9,
     public void Each(Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -173,6 +189,7 @@ public void Each(Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T
     public void Each(Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -183,6 +200,7 @@ public void Each(Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8,
     public void Each(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -193,6 +211,7 @@ public void Each(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10
     public void Each(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -203,6 +222,7 @@ public void Each(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*,
     public void Each(delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -213,6 +233,7 @@ public void Each(delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8
     public Entity Find(Ecs.FindRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -223,6 +244,7 @@ public Entity Find(Ecs.FindRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T
     public Entity Find(Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -233,6 +255,7 @@ public Entity Find(Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8,
     public Entity Find(Ecs.FindIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -243,6 +266,7 @@ public Entity Find(Ecs.FindIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T
     public Entity Find(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -253,6 +277,7 @@ public Entity Find(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref
     public Entity Find(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -263,6 +288,7 @@ public Entity Find(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref
     public Entity Find(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -273,6 +299,7 @@ public Entity Find(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4,
     public Entity Find(Ecs.FindPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -283,6 +310,7 @@ public Entity Find(Ecs.FindPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T
     public Entity Find(Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -293,6 +321,7 @@ public Entity Find(Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7,
     public Entity Find(Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -303,6 +332,7 @@ public Entity Find(Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T
     public Entity Find(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -313,6 +343,7 @@ public Entity Find(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T
     public Entity Find(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -323,6 +354,7 @@ public Entity Find(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*
     public Entity Find(delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 }
\ No newline at end of file
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/WorkerIterable/WorkerIterable.IIterable/T14.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/WorkerIterable/WorkerIterable.IIterable/T14.g.cs
index c2fe32cc..050e2a1a 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/WorkerIterable/WorkerIterable.IIterable/T14.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/WorkerIterable/WorkerIterable.IIterable/T14.g.cs
@@ -13,6 +13,7 @@ public unsafe partial struct WorkerIterable<T0, T1, T2, T3, T4, T5, T6, T7, T8,
     public void Run(Ecs.RunCallback callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Run(ref this, callback);
     }
 
@@ -23,6 +24,7 @@ public void Run(Ecs.RunCallback callback)
     public void Run(delegate*<Iter, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Run(ref this, callback);
     }
 
@@ -33,6 +35,7 @@ public void Run(delegate*<Iter, void> callback)
     public void Iter(Ecs.IterFieldCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -43,6 +46,7 @@ public void Iter(Ecs.IterFieldCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T
     public void Iter(Ecs.IterSpanCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -53,6 +57,7 @@ public void Iter(Ecs.IterSpanCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T1
     public void Iter(Ecs.IterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -63,6 +68,7 @@ public void Iter(Ecs.IterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9,
     public void Iter(delegate*<Iter, Field<T0>, Field<T1>, Field<T2>, Field<T3>, Field<T4>, Field<T5>, Field<T6>, Field<T7>, Field<T8>, Field<T9>, Field<T10>, Field<T11>, Field<T12>, Field<T13>, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -73,6 +79,7 @@ public void Iter(delegate*<Iter, Field<T0>, Field<T1>, Field<T2>, Field<T3>, Fie
     public void Iter(delegate*<Iter, Span<T0>, Span<T1>, Span<T2>, Span<T3>, Span<T4>, Span<T5>, Span<T6>, Span<T7>, Span<T8>, Span<T9>, Span<T10>, Span<T11>, Span<T12>, Span<T13>, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -83,6 +90,7 @@ public void Iter(delegate*<Iter, Span<T0>, Span<T1>, Span<T2>, Span<T3>, Span<T4
     public void Iter(delegate*<Iter, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -93,6 +101,7 @@ public void Iter(delegate*<Iter, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9
     public void Each(Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -103,6 +112,7 @@ public void Each(Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10
     public void Each(Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -113,6 +123,7 @@ public void Each(Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T
     public void Each(Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -123,6 +134,7 @@ public void Each(Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9,
     public void Each(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -133,6 +145,7 @@ public void Each(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T
     public void Each(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -143,6 +156,7 @@ public void Each(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T
     public void Each(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -153,6 +167,7 @@ public void Each(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, re
     public void Each(Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -163,6 +178,7 @@ public void Each(Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9,
     public void Each(Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -173,6 +189,7 @@ public void Each(Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T
     public void Each(Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -183,6 +200,7 @@ public void Each(Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8,
     public void Each(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -193,6 +211,7 @@ public void Each(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10
     public void Each(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -203,6 +222,7 @@ public void Each(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*,
     public void Each(delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -213,6 +233,7 @@ public void Each(delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8
     public Entity Find(Ecs.FindRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -223,6 +244,7 @@ public Entity Find(Ecs.FindRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T
     public Entity Find(Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -233,6 +255,7 @@ public Entity Find(Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8,
     public Entity Find(Ecs.FindIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -243,6 +266,7 @@ public Entity Find(Ecs.FindIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T
     public Entity Find(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -253,6 +277,7 @@ public Entity Find(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref
     public Entity Find(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -263,6 +288,7 @@ public Entity Find(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref
     public Entity Find(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -273,6 +299,7 @@ public Entity Find(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4,
     public Entity Find(Ecs.FindPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -283,6 +310,7 @@ public Entity Find(Ecs.FindPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T
     public Entity Find(Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -293,6 +321,7 @@ public Entity Find(Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7,
     public Entity Find(Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -303,6 +332,7 @@ public Entity Find(Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T
     public Entity Find(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -313,6 +343,7 @@ public Entity Find(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T
     public Entity Find(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -323,6 +354,7 @@ public Entity Find(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*
     public Entity Find(delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 }
\ No newline at end of file
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/WorkerIterable/WorkerIterable.IIterable/T15.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/WorkerIterable/WorkerIterable.IIterable/T15.g.cs
index 44d6211b..84de28a3 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/WorkerIterable/WorkerIterable.IIterable/T15.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/WorkerIterable/WorkerIterable.IIterable/T15.g.cs
@@ -13,6 +13,7 @@ public unsafe partial struct WorkerIterable<T0, T1, T2, T3, T4, T5, T6, T7, T8,
     public void Run(Ecs.RunCallback callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Run(ref this, callback);
     }
 
@@ -23,6 +24,7 @@ public void Run(Ecs.RunCallback callback)
     public void Run(delegate*<Iter, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Run(ref this, callback);
     }
 
@@ -33,6 +35,7 @@ public void Run(delegate*<Iter, void> callback)
     public void Iter(Ecs.IterFieldCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -43,6 +46,7 @@ public void Iter(Ecs.IterFieldCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T
     public void Iter(Ecs.IterSpanCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -53,6 +57,7 @@ public void Iter(Ecs.IterSpanCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T1
     public void Iter(Ecs.IterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -63,6 +68,7 @@ public void Iter(Ecs.IterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9,
     public void Iter(delegate*<Iter, Field<T0>, Field<T1>, Field<T2>, Field<T3>, Field<T4>, Field<T5>, Field<T6>, Field<T7>, Field<T8>, Field<T9>, Field<T10>, Field<T11>, Field<T12>, Field<T13>, Field<T14>, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -73,6 +79,7 @@ public void Iter(delegate*<Iter, Field<T0>, Field<T1>, Field<T2>, Field<T3>, Fie
     public void Iter(delegate*<Iter, Span<T0>, Span<T1>, Span<T2>, Span<T3>, Span<T4>, Span<T5>, Span<T6>, Span<T7>, Span<T8>, Span<T9>, Span<T10>, Span<T11>, Span<T12>, Span<T13>, Span<T14>, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -83,6 +90,7 @@ public void Iter(delegate*<Iter, Span<T0>, Span<T1>, Span<T2>, Span<T3>, Span<T4
     public void Iter(delegate*<Iter, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, T14*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -93,6 +101,7 @@ public void Iter(delegate*<Iter, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9
     public void Each(Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -103,6 +112,7 @@ public void Each(Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10
     public void Each(Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -113,6 +123,7 @@ public void Each(Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T
     public void Each(Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -123,6 +134,7 @@ public void Each(Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9,
     public void Each(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, ref T14, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -133,6 +145,7 @@ public void Each(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T
     public void Each(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, ref T14, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -143,6 +156,7 @@ public void Each(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T
     public void Each(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, ref T14, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -153,6 +167,7 @@ public void Each(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, re
     public void Each(Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -163,6 +178,7 @@ public void Each(Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9,
     public void Each(Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -173,6 +189,7 @@ public void Each(Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T
     public void Each(Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -183,6 +200,7 @@ public void Each(Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8,
     public void Each(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, T14*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -193,6 +211,7 @@ public void Each(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10
     public void Each(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, T14*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -203,6 +222,7 @@ public void Each(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*,
     public void Each(delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, T14*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -213,6 +233,7 @@ public void Each(delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8
     public Entity Find(Ecs.FindRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -223,6 +244,7 @@ public Entity Find(Ecs.FindRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T
     public Entity Find(Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -233,6 +255,7 @@ public Entity Find(Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8,
     public Entity Find(Ecs.FindIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -243,6 +266,7 @@ public Entity Find(Ecs.FindIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T
     public Entity Find(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, ref T14, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -253,6 +277,7 @@ public Entity Find(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref
     public Entity Find(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, ref T14, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -263,6 +288,7 @@ public Entity Find(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref
     public Entity Find(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, ref T14, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -273,6 +299,7 @@ public Entity Find(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4,
     public Entity Find(Ecs.FindPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -283,6 +310,7 @@ public Entity Find(Ecs.FindPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T
     public Entity Find(Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -293,6 +321,7 @@ public Entity Find(Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7,
     public Entity Find(Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -303,6 +332,7 @@ public Entity Find(Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T
     public Entity Find(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, T14*, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -313,6 +343,7 @@ public Entity Find(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T
     public Entity Find(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, T14*, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -323,6 +354,7 @@ public Entity Find(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*
     public Entity Find(delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, T14*, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 }
\ No newline at end of file
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/WorkerIterable/WorkerIterable.IIterable/T16.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/WorkerIterable/WorkerIterable.IIterable/T16.g.cs
index 63c54651..7bb807f1 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/WorkerIterable/WorkerIterable.IIterable/T16.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/WorkerIterable/WorkerIterable.IIterable/T16.g.cs
@@ -13,6 +13,7 @@ public unsafe partial struct WorkerIterable<T0, T1, T2, T3, T4, T5, T6, T7, T8,
     public void Run(Ecs.RunCallback callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Run(ref this, callback);
     }
 
@@ -23,6 +24,7 @@ public void Run(Ecs.RunCallback callback)
     public void Run(delegate*<Iter, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Run(ref this, callback);
     }
 
@@ -33,6 +35,7 @@ public void Run(delegate*<Iter, void> callback)
     public void Iter(Ecs.IterFieldCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -43,6 +46,7 @@ public void Iter(Ecs.IterFieldCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T
     public void Iter(Ecs.IterSpanCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -53,6 +57,7 @@ public void Iter(Ecs.IterSpanCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T1
     public void Iter(Ecs.IterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -63,6 +68,7 @@ public void Iter(Ecs.IterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9,
     public void Iter(delegate*<Iter, Field<T0>, Field<T1>, Field<T2>, Field<T3>, Field<T4>, Field<T5>, Field<T6>, Field<T7>, Field<T8>, Field<T9>, Field<T10>, Field<T11>, Field<T12>, Field<T13>, Field<T14>, Field<T15>, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -73,6 +79,7 @@ public void Iter(delegate*<Iter, Field<T0>, Field<T1>, Field<T2>, Field<T3>, Fie
     public void Iter(delegate*<Iter, Span<T0>, Span<T1>, Span<T2>, Span<T3>, Span<T4>, Span<T5>, Span<T6>, Span<T7>, Span<T8>, Span<T9>, Span<T10>, Span<T11>, Span<T12>, Span<T13>, Span<T14>, Span<T15>, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -83,6 +90,7 @@ public void Iter(delegate*<Iter, Span<T0>, Span<T1>, Span<T2>, Span<T3>, Span<T4
     public void Iter(delegate*<Iter, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, T14*, T15*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -93,6 +101,7 @@ public void Iter(delegate*<Iter, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9
     public void Each(Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -103,6 +112,7 @@ public void Each(Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10
     public void Each(Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -113,6 +123,7 @@ public void Each(Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T
     public void Each(Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -123,6 +134,7 @@ public void Each(Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9,
     public void Each(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, ref T14, ref T15, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -133,6 +145,7 @@ public void Each(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T
     public void Each(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, ref T14, ref T15, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -143,6 +156,7 @@ public void Each(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T
     public void Each(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, ref T14, ref T15, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -153,6 +167,7 @@ public void Each(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, re
     public void Each(Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -163,6 +178,7 @@ public void Each(Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9,
     public void Each(Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -173,6 +189,7 @@ public void Each(Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T
     public void Each(Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -183,6 +200,7 @@ public void Each(Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8,
     public void Each(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, T14*, T15*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -193,6 +211,7 @@ public void Each(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10
     public void Each(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, T14*, T15*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -203,6 +222,7 @@ public void Each(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*,
     public void Each(delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, T14*, T15*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -213,6 +233,7 @@ public void Each(delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8
     public Entity Find(Ecs.FindRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -223,6 +244,7 @@ public Entity Find(Ecs.FindRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T
     public Entity Find(Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -233,6 +255,7 @@ public Entity Find(Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8,
     public Entity Find(Ecs.FindIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -243,6 +266,7 @@ public Entity Find(Ecs.FindIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T
     public Entity Find(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, ref T14, ref T15, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -253,6 +277,7 @@ public Entity Find(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref
     public Entity Find(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, ref T14, ref T15, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -263,6 +288,7 @@ public Entity Find(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref
     public Entity Find(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, ref T9, ref T10, ref T11, ref T12, ref T13, ref T14, ref T15, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -273,6 +299,7 @@ public Entity Find(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4,
     public Entity Find(Ecs.FindPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -283,6 +310,7 @@ public Entity Find(Ecs.FindPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T
     public Entity Find(Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -293,6 +321,7 @@ public Entity Find(Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7,
     public Entity Find(Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -303,6 +332,7 @@ public Entity Find(Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T
     public Entity Find(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, T14*, T15*, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -313,6 +343,7 @@ public Entity Find(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T
     public Entity Find(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, T14*, T15*, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -323,6 +354,7 @@ public Entity Find(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*
     public Entity Find(delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, T9*, T10*, T11*, T12*, T13*, T14*, T15*, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 }
\ No newline at end of file
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/WorkerIterable/WorkerIterable.IIterable/T2.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/WorkerIterable/WorkerIterable.IIterable/T2.g.cs
index cac9066e..931b6a30 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/WorkerIterable/WorkerIterable.IIterable/T2.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/WorkerIterable/WorkerIterable.IIterable/T2.g.cs
@@ -13,6 +13,7 @@ public unsafe partial struct WorkerIterable<T0, T1>
     public void Run(Ecs.RunCallback callback)
     {
         TypeHelper<T0, T1>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Run(ref this, callback);
     }
 
@@ -23,6 +24,7 @@ public void Run(Ecs.RunCallback callback)
     public void Run(delegate*<Iter, void> callback)
     {
         TypeHelper<T0, T1>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Run(ref this, callback);
     }
 
@@ -33,6 +35,7 @@ public void Run(delegate*<Iter, void> callback)
     public void Iter(Ecs.IterFieldCallback<T0, T1> callback)
     {
         TypeHelper<T0, T1>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -43,6 +46,7 @@ public void Iter(Ecs.IterFieldCallback<T0, T1> callback)
     public void Iter(Ecs.IterSpanCallback<T0, T1> callback)
     {
         TypeHelper<T0, T1>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -53,6 +57,7 @@ public void Iter(Ecs.IterSpanCallback<T0, T1> callback)
     public void Iter(Ecs.IterPointerCallback<T0, T1> callback)
     {
         TypeHelper<T0, T1>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -63,6 +68,7 @@ public void Iter(Ecs.IterPointerCallback<T0, T1> callback)
     public void Iter(delegate*<Iter, Field<T0>, Field<T1>, void> callback)
     {
         TypeHelper<T0, T1>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -73,6 +79,7 @@ public void Iter(delegate*<Iter, Field<T0>, Field<T1>, void> callback)
     public void Iter(delegate*<Iter, Span<T0>, Span<T1>, void> callback)
     {
         TypeHelper<T0, T1>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -83,6 +90,7 @@ public void Iter(delegate*<Iter, Span<T0>, Span<T1>, void> callback)
     public void Iter(delegate*<Iter, T0*, T1*, void> callback)
     {
         TypeHelper<T0, T1>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -93,6 +101,7 @@ public void Iter(delegate*<Iter, T0*, T1*, void> callback)
     public void Each(Ecs.EachRefCallback<T0, T1> callback)
     {
         TypeHelper<T0, T1>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -103,6 +112,7 @@ public void Each(Ecs.EachRefCallback<T0, T1> callback)
     public void Each(Ecs.EachEntityRefCallback<T0, T1> callback)
     {
         TypeHelper<T0, T1>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -113,6 +123,7 @@ public void Each(Ecs.EachEntityRefCallback<T0, T1> callback)
     public void Each(Ecs.EachIterRefCallback<T0, T1> callback)
     {
         TypeHelper<T0, T1>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -123,6 +134,7 @@ public void Each(Ecs.EachIterRefCallback<T0, T1> callback)
     public void Each(delegate*<ref T0, ref T1, void> callback)
     {
         TypeHelper<T0, T1>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -133,6 +145,7 @@ public void Each(delegate*<ref T0, ref T1, void> callback)
     public void Each(delegate*<Entity, ref T0, ref T1, void> callback)
     {
         TypeHelper<T0, T1>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -143,6 +156,7 @@ public void Each(delegate*<Entity, ref T0, ref T1, void> callback)
     public void Each(delegate*<Iter, int, ref T0, ref T1, void> callback)
     {
         TypeHelper<T0, T1>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -153,6 +167,7 @@ public void Each(delegate*<Iter, int, ref T0, ref T1, void> callback)
     public void Each(Ecs.EachPointerCallback<T0, T1> callback)
     {
         TypeHelper<T0, T1>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -163,6 +178,7 @@ public void Each(Ecs.EachPointerCallback<T0, T1> callback)
     public void Each(Ecs.EachEntityPointerCallback<T0, T1> callback)
     {
         TypeHelper<T0, T1>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -173,6 +189,7 @@ public void Each(Ecs.EachEntityPointerCallback<T0, T1> callback)
     public void Each(Ecs.EachIterPointerCallback<T0, T1> callback)
     {
         TypeHelper<T0, T1>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -183,6 +200,7 @@ public void Each(Ecs.EachIterPointerCallback<T0, T1> callback)
     public void Each(delegate*<T0*, T1*, void> callback)
     {
         TypeHelper<T0, T1>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -193,6 +211,7 @@ public void Each(delegate*<T0*, T1*, void> callback)
     public void Each(delegate*<Entity, T0*, T1*, void> callback)
     {
         TypeHelper<T0, T1>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -203,6 +222,7 @@ public void Each(delegate*<Entity, T0*, T1*, void> callback)
     public void Each(delegate*<Iter, int, T0*, T1*, void> callback)
     {
         TypeHelper<T0, T1>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -213,6 +233,7 @@ public void Each(delegate*<Iter, int, T0*, T1*, void> callback)
     public Entity Find(Ecs.FindRefCallback<T0, T1> callback)
     {
         TypeHelper<T0, T1>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -223,6 +244,7 @@ public Entity Find(Ecs.FindRefCallback<T0, T1> callback)
     public Entity Find(Ecs.FindEntityRefCallback<T0, T1> callback)
     {
         TypeHelper<T0, T1>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -233,6 +255,7 @@ public Entity Find(Ecs.FindEntityRefCallback<T0, T1> callback)
     public Entity Find(Ecs.FindIterRefCallback<T0, T1> callback)
     {
         TypeHelper<T0, T1>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -243,6 +266,7 @@ public Entity Find(Ecs.FindIterRefCallback<T0, T1> callback)
     public Entity Find(delegate*<ref T0, ref T1, bool> callback)
     {
         TypeHelper<T0, T1>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -253,6 +277,7 @@ public Entity Find(delegate*<ref T0, ref T1, bool> callback)
     public Entity Find(delegate*<Entity, ref T0, ref T1, bool> callback)
     {
         TypeHelper<T0, T1>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -263,6 +288,7 @@ public Entity Find(delegate*<Entity, ref T0, ref T1, bool> callback)
     public Entity Find(delegate*<Iter, int, ref T0, ref T1, bool> callback)
     {
         TypeHelper<T0, T1>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -273,6 +299,7 @@ public Entity Find(delegate*<Iter, int, ref T0, ref T1, bool> callback)
     public Entity Find(Ecs.FindPointerCallback<T0, T1> callback)
     {
         TypeHelper<T0, T1>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -283,6 +310,7 @@ public Entity Find(Ecs.FindPointerCallback<T0, T1> callback)
     public Entity Find(Ecs.FindEntityPointerCallback<T0, T1> callback)
     {
         TypeHelper<T0, T1>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -293,6 +321,7 @@ public Entity Find(Ecs.FindEntityPointerCallback<T0, T1> callback)
     public Entity Find(Ecs.FindIterPointerCallback<T0, T1> callback)
     {
         TypeHelper<T0, T1>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -303,6 +332,7 @@ public Entity Find(Ecs.FindIterPointerCallback<T0, T1> callback)
     public Entity Find(delegate*<T0*, T1*, bool> callback)
     {
         TypeHelper<T0, T1>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -313,6 +343,7 @@ public Entity Find(delegate*<T0*, T1*, bool> callback)
     public Entity Find(delegate*<Entity, T0*, T1*, bool> callback)
     {
         TypeHelper<T0, T1>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -323,6 +354,7 @@ public Entity Find(delegate*<Entity, T0*, T1*, bool> callback)
     public Entity Find(delegate*<Iter, int, T0*, T1*, bool> callback)
     {
         TypeHelper<T0, T1>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 }
\ No newline at end of file
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/WorkerIterable/WorkerIterable.IIterable/T3.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/WorkerIterable/WorkerIterable.IIterable/T3.g.cs
index be966ad9..40876d8a 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/WorkerIterable/WorkerIterable.IIterable/T3.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/WorkerIterable/WorkerIterable.IIterable/T3.g.cs
@@ -13,6 +13,7 @@ public unsafe partial struct WorkerIterable<T0, T1, T2>
     public void Run(Ecs.RunCallback callback)
     {
         TypeHelper<T0, T1, T2>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Run(ref this, callback);
     }
 
@@ -23,6 +24,7 @@ public void Run(Ecs.RunCallback callback)
     public void Run(delegate*<Iter, void> callback)
     {
         TypeHelper<T0, T1, T2>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Run(ref this, callback);
     }
 
@@ -33,6 +35,7 @@ public void Run(delegate*<Iter, void> callback)
     public void Iter(Ecs.IterFieldCallback<T0, T1, T2> callback)
     {
         TypeHelper<T0, T1, T2>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -43,6 +46,7 @@ public void Iter(Ecs.IterFieldCallback<T0, T1, T2> callback)
     public void Iter(Ecs.IterSpanCallback<T0, T1, T2> callback)
     {
         TypeHelper<T0, T1, T2>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -53,6 +57,7 @@ public void Iter(Ecs.IterSpanCallback<T0, T1, T2> callback)
     public void Iter(Ecs.IterPointerCallback<T0, T1, T2> callback)
     {
         TypeHelper<T0, T1, T2>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -63,6 +68,7 @@ public void Iter(Ecs.IterPointerCallback<T0, T1, T2> callback)
     public void Iter(delegate*<Iter, Field<T0>, Field<T1>, Field<T2>, void> callback)
     {
         TypeHelper<T0, T1, T2>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -73,6 +79,7 @@ public void Iter(delegate*<Iter, Field<T0>, Field<T1>, Field<T2>, void> callback
     public void Iter(delegate*<Iter, Span<T0>, Span<T1>, Span<T2>, void> callback)
     {
         TypeHelper<T0, T1, T2>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -83,6 +90,7 @@ public void Iter(delegate*<Iter, Span<T0>, Span<T1>, Span<T2>, void> callback)
     public void Iter(delegate*<Iter, T0*, T1*, T2*, void> callback)
     {
         TypeHelper<T0, T1, T2>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -93,6 +101,7 @@ public void Iter(delegate*<Iter, T0*, T1*, T2*, void> callback)
     public void Each(Ecs.EachRefCallback<T0, T1, T2> callback)
     {
         TypeHelper<T0, T1, T2>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -103,6 +112,7 @@ public void Each(Ecs.EachRefCallback<T0, T1, T2> callback)
     public void Each(Ecs.EachEntityRefCallback<T0, T1, T2> callback)
     {
         TypeHelper<T0, T1, T2>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -113,6 +123,7 @@ public void Each(Ecs.EachEntityRefCallback<T0, T1, T2> callback)
     public void Each(Ecs.EachIterRefCallback<T0, T1, T2> callback)
     {
         TypeHelper<T0, T1, T2>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -123,6 +134,7 @@ public void Each(Ecs.EachIterRefCallback<T0, T1, T2> callback)
     public void Each(delegate*<ref T0, ref T1, ref T2, void> callback)
     {
         TypeHelper<T0, T1, T2>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -133,6 +145,7 @@ public void Each(delegate*<ref T0, ref T1, ref T2, void> callback)
     public void Each(delegate*<Entity, ref T0, ref T1, ref T2, void> callback)
     {
         TypeHelper<T0, T1, T2>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -143,6 +156,7 @@ public void Each(delegate*<Entity, ref T0, ref T1, ref T2, void> callback)
     public void Each(delegate*<Iter, int, ref T0, ref T1, ref T2, void> callback)
     {
         TypeHelper<T0, T1, T2>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -153,6 +167,7 @@ public void Each(delegate*<Iter, int, ref T0, ref T1, ref T2, void> callback)
     public void Each(Ecs.EachPointerCallback<T0, T1, T2> callback)
     {
         TypeHelper<T0, T1, T2>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -163,6 +178,7 @@ public void Each(Ecs.EachPointerCallback<T0, T1, T2> callback)
     public void Each(Ecs.EachEntityPointerCallback<T0, T1, T2> callback)
     {
         TypeHelper<T0, T1, T2>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -173,6 +189,7 @@ public void Each(Ecs.EachEntityPointerCallback<T0, T1, T2> callback)
     public void Each(Ecs.EachIterPointerCallback<T0, T1, T2> callback)
     {
         TypeHelper<T0, T1, T2>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -183,6 +200,7 @@ public void Each(Ecs.EachIterPointerCallback<T0, T1, T2> callback)
     public void Each(delegate*<T0*, T1*, T2*, void> callback)
     {
         TypeHelper<T0, T1, T2>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -193,6 +211,7 @@ public void Each(delegate*<T0*, T1*, T2*, void> callback)
     public void Each(delegate*<Entity, T0*, T1*, T2*, void> callback)
     {
         TypeHelper<T0, T1, T2>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -203,6 +222,7 @@ public void Each(delegate*<Entity, T0*, T1*, T2*, void> callback)
     public void Each(delegate*<Iter, int, T0*, T1*, T2*, void> callback)
     {
         TypeHelper<T0, T1, T2>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -213,6 +233,7 @@ public void Each(delegate*<Iter, int, T0*, T1*, T2*, void> callback)
     public Entity Find(Ecs.FindRefCallback<T0, T1, T2> callback)
     {
         TypeHelper<T0, T1, T2>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -223,6 +244,7 @@ public Entity Find(Ecs.FindRefCallback<T0, T1, T2> callback)
     public Entity Find(Ecs.FindEntityRefCallback<T0, T1, T2> callback)
     {
         TypeHelper<T0, T1, T2>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -233,6 +255,7 @@ public Entity Find(Ecs.FindEntityRefCallback<T0, T1, T2> callback)
     public Entity Find(Ecs.FindIterRefCallback<T0, T1, T2> callback)
     {
         TypeHelper<T0, T1, T2>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -243,6 +266,7 @@ public Entity Find(Ecs.FindIterRefCallback<T0, T1, T2> callback)
     public Entity Find(delegate*<ref T0, ref T1, ref T2, bool> callback)
     {
         TypeHelper<T0, T1, T2>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -253,6 +277,7 @@ public Entity Find(delegate*<ref T0, ref T1, ref T2, bool> callback)
     public Entity Find(delegate*<Entity, ref T0, ref T1, ref T2, bool> callback)
     {
         TypeHelper<T0, T1, T2>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -263,6 +288,7 @@ public Entity Find(delegate*<Entity, ref T0, ref T1, ref T2, bool> callback)
     public Entity Find(delegate*<Iter, int, ref T0, ref T1, ref T2, bool> callback)
     {
         TypeHelper<T0, T1, T2>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -273,6 +299,7 @@ public Entity Find(delegate*<Iter, int, ref T0, ref T1, ref T2, bool> callback)
     public Entity Find(Ecs.FindPointerCallback<T0, T1, T2> callback)
     {
         TypeHelper<T0, T1, T2>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -283,6 +310,7 @@ public Entity Find(Ecs.FindPointerCallback<T0, T1, T2> callback)
     public Entity Find(Ecs.FindEntityPointerCallback<T0, T1, T2> callback)
     {
         TypeHelper<T0, T1, T2>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -293,6 +321,7 @@ public Entity Find(Ecs.FindEntityPointerCallback<T0, T1, T2> callback)
     public Entity Find(Ecs.FindIterPointerCallback<T0, T1, T2> callback)
     {
         TypeHelper<T0, T1, T2>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -303,6 +332,7 @@ public Entity Find(Ecs.FindIterPointerCallback<T0, T1, T2> callback)
     public Entity Find(delegate*<T0*, T1*, T2*, bool> callback)
     {
         TypeHelper<T0, T1, T2>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -313,6 +343,7 @@ public Entity Find(delegate*<T0*, T1*, T2*, bool> callback)
     public Entity Find(delegate*<Entity, T0*, T1*, T2*, bool> callback)
     {
         TypeHelper<T0, T1, T2>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -323,6 +354,7 @@ public Entity Find(delegate*<Entity, T0*, T1*, T2*, bool> callback)
     public Entity Find(delegate*<Iter, int, T0*, T1*, T2*, bool> callback)
     {
         TypeHelper<T0, T1, T2>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 }
\ No newline at end of file
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/WorkerIterable/WorkerIterable.IIterable/T4.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/WorkerIterable/WorkerIterable.IIterable/T4.g.cs
index 5503a077..c1201e9c 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/WorkerIterable/WorkerIterable.IIterable/T4.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/WorkerIterable/WorkerIterable.IIterable/T4.g.cs
@@ -13,6 +13,7 @@ public unsafe partial struct WorkerIterable<T0, T1, T2, T3>
     public void Run(Ecs.RunCallback callback)
     {
         TypeHelper<T0, T1, T2, T3>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Run(ref this, callback);
     }
 
@@ -23,6 +24,7 @@ public void Run(Ecs.RunCallback callback)
     public void Run(delegate*<Iter, void> callback)
     {
         TypeHelper<T0, T1, T2, T3>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Run(ref this, callback);
     }
 
@@ -33,6 +35,7 @@ public void Run(delegate*<Iter, void> callback)
     public void Iter(Ecs.IterFieldCallback<T0, T1, T2, T3> callback)
     {
         TypeHelper<T0, T1, T2, T3>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -43,6 +46,7 @@ public void Iter(Ecs.IterFieldCallback<T0, T1, T2, T3> callback)
     public void Iter(Ecs.IterSpanCallback<T0, T1, T2, T3> callback)
     {
         TypeHelper<T0, T1, T2, T3>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -53,6 +57,7 @@ public void Iter(Ecs.IterSpanCallback<T0, T1, T2, T3> callback)
     public void Iter(Ecs.IterPointerCallback<T0, T1, T2, T3> callback)
     {
         TypeHelper<T0, T1, T2, T3>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -63,6 +68,7 @@ public void Iter(Ecs.IterPointerCallback<T0, T1, T2, T3> callback)
     public void Iter(delegate*<Iter, Field<T0>, Field<T1>, Field<T2>, Field<T3>, void> callback)
     {
         TypeHelper<T0, T1, T2, T3>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -73,6 +79,7 @@ public void Iter(delegate*<Iter, Field<T0>, Field<T1>, Field<T2>, Field<T3>, voi
     public void Iter(delegate*<Iter, Span<T0>, Span<T1>, Span<T2>, Span<T3>, void> callback)
     {
         TypeHelper<T0, T1, T2, T3>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -83,6 +90,7 @@ public void Iter(delegate*<Iter, Span<T0>, Span<T1>, Span<T2>, Span<T3>, void> c
     public void Iter(delegate*<Iter, T0*, T1*, T2*, T3*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -93,6 +101,7 @@ public void Iter(delegate*<Iter, T0*, T1*, T2*, T3*, void> callback)
     public void Each(Ecs.EachRefCallback<T0, T1, T2, T3> callback)
     {
         TypeHelper<T0, T1, T2, T3>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -103,6 +112,7 @@ public void Each(Ecs.EachRefCallback<T0, T1, T2, T3> callback)
     public void Each(Ecs.EachEntityRefCallback<T0, T1, T2, T3> callback)
     {
         TypeHelper<T0, T1, T2, T3>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -113,6 +123,7 @@ public void Each(Ecs.EachEntityRefCallback<T0, T1, T2, T3> callback)
     public void Each(Ecs.EachIterRefCallback<T0, T1, T2, T3> callback)
     {
         TypeHelper<T0, T1, T2, T3>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -123,6 +134,7 @@ public void Each(Ecs.EachIterRefCallback<T0, T1, T2, T3> callback)
     public void Each(delegate*<ref T0, ref T1, ref T2, ref T3, void> callback)
     {
         TypeHelper<T0, T1, T2, T3>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -133,6 +145,7 @@ public void Each(delegate*<ref T0, ref T1, ref T2, ref T3, void> callback)
     public void Each(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, void> callback)
     {
         TypeHelper<T0, T1, T2, T3>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -143,6 +156,7 @@ public void Each(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, void> callbac
     public void Each(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, void> callback)
     {
         TypeHelper<T0, T1, T2, T3>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -153,6 +167,7 @@ public void Each(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, void> call
     public void Each(Ecs.EachPointerCallback<T0, T1, T2, T3> callback)
     {
         TypeHelper<T0, T1, T2, T3>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -163,6 +178,7 @@ public void Each(Ecs.EachPointerCallback<T0, T1, T2, T3> callback)
     public void Each(Ecs.EachEntityPointerCallback<T0, T1, T2, T3> callback)
     {
         TypeHelper<T0, T1, T2, T3>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -173,6 +189,7 @@ public void Each(Ecs.EachEntityPointerCallback<T0, T1, T2, T3> callback)
     public void Each(Ecs.EachIterPointerCallback<T0, T1, T2, T3> callback)
     {
         TypeHelper<T0, T1, T2, T3>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -183,6 +200,7 @@ public void Each(Ecs.EachIterPointerCallback<T0, T1, T2, T3> callback)
     public void Each(delegate*<T0*, T1*, T2*, T3*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -193,6 +211,7 @@ public void Each(delegate*<T0*, T1*, T2*, T3*, void> callback)
     public void Each(delegate*<Entity, T0*, T1*, T2*, T3*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -203,6 +222,7 @@ public void Each(delegate*<Entity, T0*, T1*, T2*, T3*, void> callback)
     public void Each(delegate*<Iter, int, T0*, T1*, T2*, T3*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -213,6 +233,7 @@ public void Each(delegate*<Iter, int, T0*, T1*, T2*, T3*, void> callback)
     public Entity Find(Ecs.FindRefCallback<T0, T1, T2, T3> callback)
     {
         TypeHelper<T0, T1, T2, T3>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -223,6 +244,7 @@ public Entity Find(Ecs.FindRefCallback<T0, T1, T2, T3> callback)
     public Entity Find(Ecs.FindEntityRefCallback<T0, T1, T2, T3> callback)
     {
         TypeHelper<T0, T1, T2, T3>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -233,6 +255,7 @@ public Entity Find(Ecs.FindEntityRefCallback<T0, T1, T2, T3> callback)
     public Entity Find(Ecs.FindIterRefCallback<T0, T1, T2, T3> callback)
     {
         TypeHelper<T0, T1, T2, T3>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -243,6 +266,7 @@ public Entity Find(Ecs.FindIterRefCallback<T0, T1, T2, T3> callback)
     public Entity Find(delegate*<ref T0, ref T1, ref T2, ref T3, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -253,6 +277,7 @@ public Entity Find(delegate*<ref T0, ref T1, ref T2, ref T3, bool> callback)
     public Entity Find(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -263,6 +288,7 @@ public Entity Find(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, bool> callb
     public Entity Find(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -273,6 +299,7 @@ public Entity Find(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, bool> ca
     public Entity Find(Ecs.FindPointerCallback<T0, T1, T2, T3> callback)
     {
         TypeHelper<T0, T1, T2, T3>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -283,6 +310,7 @@ public Entity Find(Ecs.FindPointerCallback<T0, T1, T2, T3> callback)
     public Entity Find(Ecs.FindEntityPointerCallback<T0, T1, T2, T3> callback)
     {
         TypeHelper<T0, T1, T2, T3>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -293,6 +321,7 @@ public Entity Find(Ecs.FindEntityPointerCallback<T0, T1, T2, T3> callback)
     public Entity Find(Ecs.FindIterPointerCallback<T0, T1, T2, T3> callback)
     {
         TypeHelper<T0, T1, T2, T3>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -303,6 +332,7 @@ public Entity Find(Ecs.FindIterPointerCallback<T0, T1, T2, T3> callback)
     public Entity Find(delegate*<T0*, T1*, T2*, T3*, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -313,6 +343,7 @@ public Entity Find(delegate*<T0*, T1*, T2*, T3*, bool> callback)
     public Entity Find(delegate*<Entity, T0*, T1*, T2*, T3*, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -323,6 +354,7 @@ public Entity Find(delegate*<Entity, T0*, T1*, T2*, T3*, bool> callback)
     public Entity Find(delegate*<Iter, int, T0*, T1*, T2*, T3*, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 }
\ No newline at end of file
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/WorkerIterable/WorkerIterable.IIterable/T5.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/WorkerIterable/WorkerIterable.IIterable/T5.g.cs
index 0f7642c6..8c8f6396 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/WorkerIterable/WorkerIterable.IIterable/T5.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/WorkerIterable/WorkerIterable.IIterable/T5.g.cs
@@ -13,6 +13,7 @@ public unsafe partial struct WorkerIterable<T0, T1, T2, T3, T4>
     public void Run(Ecs.RunCallback callback)
     {
         TypeHelper<T0, T1, T2, T3, T4>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Run(ref this, callback);
     }
 
@@ -23,6 +24,7 @@ public void Run(Ecs.RunCallback callback)
     public void Run(delegate*<Iter, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Run(ref this, callback);
     }
 
@@ -33,6 +35,7 @@ public void Run(delegate*<Iter, void> callback)
     public void Iter(Ecs.IterFieldCallback<T0, T1, T2, T3, T4> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -43,6 +46,7 @@ public void Iter(Ecs.IterFieldCallback<T0, T1, T2, T3, T4> callback)
     public void Iter(Ecs.IterSpanCallback<T0, T1, T2, T3, T4> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -53,6 +57,7 @@ public void Iter(Ecs.IterSpanCallback<T0, T1, T2, T3, T4> callback)
     public void Iter(Ecs.IterPointerCallback<T0, T1, T2, T3, T4> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -63,6 +68,7 @@ public void Iter(Ecs.IterPointerCallback<T0, T1, T2, T3, T4> callback)
     public void Iter(delegate*<Iter, Field<T0>, Field<T1>, Field<T2>, Field<T3>, Field<T4>, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -73,6 +79,7 @@ public void Iter(delegate*<Iter, Field<T0>, Field<T1>, Field<T2>, Field<T3>, Fie
     public void Iter(delegate*<Iter, Span<T0>, Span<T1>, Span<T2>, Span<T3>, Span<T4>, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -83,6 +90,7 @@ public void Iter(delegate*<Iter, Span<T0>, Span<T1>, Span<T2>, Span<T3>, Span<T4
     public void Iter(delegate*<Iter, T0*, T1*, T2*, T3*, T4*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -93,6 +101,7 @@ public void Iter(delegate*<Iter, T0*, T1*, T2*, T3*, T4*, void> callback)
     public void Each(Ecs.EachRefCallback<T0, T1, T2, T3, T4> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -103,6 +112,7 @@ public void Each(Ecs.EachRefCallback<T0, T1, T2, T3, T4> callback)
     public void Each(Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -113,6 +123,7 @@ public void Each(Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4> callback)
     public void Each(Ecs.EachIterRefCallback<T0, T1, T2, T3, T4> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -123,6 +134,7 @@ public void Each(Ecs.EachIterRefCallback<T0, T1, T2, T3, T4> callback)
     public void Each(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -133,6 +145,7 @@ public void Each(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, void> callbac
     public void Each(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -143,6 +156,7 @@ public void Each(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, void>
     public void Each(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -153,6 +167,7 @@ public void Each(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, vo
     public void Each(Ecs.EachPointerCallback<T0, T1, T2, T3, T4> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -163,6 +178,7 @@ public void Each(Ecs.EachPointerCallback<T0, T1, T2, T3, T4> callback)
     public void Each(Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -173,6 +189,7 @@ public void Each(Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4> callback)
     public void Each(Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -183,6 +200,7 @@ public void Each(Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4> callback)
     public void Each(delegate*<T0*, T1*, T2*, T3*, T4*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -193,6 +211,7 @@ public void Each(delegate*<T0*, T1*, T2*, T3*, T4*, void> callback)
     public void Each(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -203,6 +222,7 @@ public void Each(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, void> callback)
     public void Each(delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -213,6 +233,7 @@ public void Each(delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, void> callback)
     public Entity Find(Ecs.FindRefCallback<T0, T1, T2, T3, T4> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -223,6 +244,7 @@ public Entity Find(Ecs.FindRefCallback<T0, T1, T2, T3, T4> callback)
     public Entity Find(Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -233,6 +255,7 @@ public Entity Find(Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4> callback)
     public Entity Find(Ecs.FindIterRefCallback<T0, T1, T2, T3, T4> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -243,6 +266,7 @@ public Entity Find(Ecs.FindIterRefCallback<T0, T1, T2, T3, T4> callback)
     public Entity Find(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -253,6 +277,7 @@ public Entity Find(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, bool> callb
     public Entity Find(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -263,6 +288,7 @@ public Entity Find(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, boo
     public Entity Find(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -273,6 +299,7 @@ public Entity Find(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4,
     public Entity Find(Ecs.FindPointerCallback<T0, T1, T2, T3, T4> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -283,6 +310,7 @@ public Entity Find(Ecs.FindPointerCallback<T0, T1, T2, T3, T4> callback)
     public Entity Find(Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -293,6 +321,7 @@ public Entity Find(Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4> callback)
     public Entity Find(Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -303,6 +332,7 @@ public Entity Find(Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4> callback)
     public Entity Find(delegate*<T0*, T1*, T2*, T3*, T4*, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -313,6 +343,7 @@ public Entity Find(delegate*<T0*, T1*, T2*, T3*, T4*, bool> callback)
     public Entity Find(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -323,6 +354,7 @@ public Entity Find(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, bool> callback)
     public Entity Find(delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 }
\ No newline at end of file
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/WorkerIterable/WorkerIterable.IIterable/T6.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/WorkerIterable/WorkerIterable.IIterable/T6.g.cs
index b16c2e4f..bc412e71 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/WorkerIterable/WorkerIterable.IIterable/T6.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/WorkerIterable/WorkerIterable.IIterable/T6.g.cs
@@ -13,6 +13,7 @@ public unsafe partial struct WorkerIterable<T0, T1, T2, T3, T4, T5>
     public void Run(Ecs.RunCallback callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Run(ref this, callback);
     }
 
@@ -23,6 +24,7 @@ public void Run(Ecs.RunCallback callback)
     public void Run(delegate*<Iter, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Run(ref this, callback);
     }
 
@@ -33,6 +35,7 @@ public void Run(delegate*<Iter, void> callback)
     public void Iter(Ecs.IterFieldCallback<T0, T1, T2, T3, T4, T5> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -43,6 +46,7 @@ public void Iter(Ecs.IterFieldCallback<T0, T1, T2, T3, T4, T5> callback)
     public void Iter(Ecs.IterSpanCallback<T0, T1, T2, T3, T4, T5> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -53,6 +57,7 @@ public void Iter(Ecs.IterSpanCallback<T0, T1, T2, T3, T4, T5> callback)
     public void Iter(Ecs.IterPointerCallback<T0, T1, T2, T3, T4, T5> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -63,6 +68,7 @@ public void Iter(Ecs.IterPointerCallback<T0, T1, T2, T3, T4, T5> callback)
     public void Iter(delegate*<Iter, Field<T0>, Field<T1>, Field<T2>, Field<T3>, Field<T4>, Field<T5>, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -73,6 +79,7 @@ public void Iter(delegate*<Iter, Field<T0>, Field<T1>, Field<T2>, Field<T3>, Fie
     public void Iter(delegate*<Iter, Span<T0>, Span<T1>, Span<T2>, Span<T3>, Span<T4>, Span<T5>, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -83,6 +90,7 @@ public void Iter(delegate*<Iter, Span<T0>, Span<T1>, Span<T2>, Span<T3>, Span<T4
     public void Iter(delegate*<Iter, T0*, T1*, T2*, T3*, T4*, T5*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -93,6 +101,7 @@ public void Iter(delegate*<Iter, T0*, T1*, T2*, T3*, T4*, T5*, void> callback)
     public void Each(Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -103,6 +112,7 @@ public void Each(Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5> callback)
     public void Each(Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -113,6 +123,7 @@ public void Each(Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5> callback)
     public void Each(Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -123,6 +134,7 @@ public void Each(Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5> callback)
     public void Each(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -133,6 +145,7 @@ public void Each(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, void>
     public void Each(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -143,6 +156,7 @@ public void Each(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T
     public void Each(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -153,6 +167,7 @@ public void Each(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, re
     public void Each(Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -163,6 +178,7 @@ public void Each(Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5> callback)
     public void Each(Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -173,6 +189,7 @@ public void Each(Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5> callback)
     public void Each(Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -183,6 +200,7 @@ public void Each(Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5> callback)
     public void Each(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -193,6 +211,7 @@ public void Each(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, void> callback)
     public void Each(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -203,6 +222,7 @@ public void Each(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, void> callback)
     public void Each(delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -213,6 +233,7 @@ public void Each(delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, void> callba
     public Entity Find(Ecs.FindRefCallback<T0, T1, T2, T3, T4, T5> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -223,6 +244,7 @@ public Entity Find(Ecs.FindRefCallback<T0, T1, T2, T3, T4, T5> callback)
     public Entity Find(Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4, T5> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -233,6 +255,7 @@ public Entity Find(Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4, T5> callback)
     public Entity Find(Ecs.FindIterRefCallback<T0, T1, T2, T3, T4, T5> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -243,6 +266,7 @@ public Entity Find(Ecs.FindIterRefCallback<T0, T1, T2, T3, T4, T5> callback)
     public Entity Find(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -253,6 +277,7 @@ public Entity Find(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, boo
     public Entity Find(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -263,6 +288,7 @@ public Entity Find(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref
     public Entity Find(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -273,6 +299,7 @@ public Entity Find(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4,
     public Entity Find(Ecs.FindPointerCallback<T0, T1, T2, T3, T4, T5> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -283,6 +310,7 @@ public Entity Find(Ecs.FindPointerCallback<T0, T1, T2, T3, T4, T5> callback)
     public Entity Find(Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4, T5> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -293,6 +321,7 @@ public Entity Find(Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4, T5> callbac
     public Entity Find(Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4, T5> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -303,6 +332,7 @@ public Entity Find(Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4, T5> callback)
     public Entity Find(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -313,6 +343,7 @@ public Entity Find(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, bool> callback)
     public Entity Find(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -323,6 +354,7 @@ public Entity Find(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, bool> callbac
     public Entity Find(delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 }
\ No newline at end of file
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/WorkerIterable/WorkerIterable.IIterable/T7.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/WorkerIterable/WorkerIterable.IIterable/T7.g.cs
index b2381d1b..a131f109 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/WorkerIterable/WorkerIterable.IIterable/T7.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/WorkerIterable/WorkerIterable.IIterable/T7.g.cs
@@ -13,6 +13,7 @@ public unsafe partial struct WorkerIterable<T0, T1, T2, T3, T4, T5, T6>
     public void Run(Ecs.RunCallback callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Run(ref this, callback);
     }
 
@@ -23,6 +24,7 @@ public void Run(Ecs.RunCallback callback)
     public void Run(delegate*<Iter, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Run(ref this, callback);
     }
 
@@ -33,6 +35,7 @@ public void Run(delegate*<Iter, void> callback)
     public void Iter(Ecs.IterFieldCallback<T0, T1, T2, T3, T4, T5, T6> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -43,6 +46,7 @@ public void Iter(Ecs.IterFieldCallback<T0, T1, T2, T3, T4, T5, T6> callback)
     public void Iter(Ecs.IterSpanCallback<T0, T1, T2, T3, T4, T5, T6> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -53,6 +57,7 @@ public void Iter(Ecs.IterSpanCallback<T0, T1, T2, T3, T4, T5, T6> callback)
     public void Iter(Ecs.IterPointerCallback<T0, T1, T2, T3, T4, T5, T6> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -63,6 +68,7 @@ public void Iter(Ecs.IterPointerCallback<T0, T1, T2, T3, T4, T5, T6> callback)
     public void Iter(delegate*<Iter, Field<T0>, Field<T1>, Field<T2>, Field<T3>, Field<T4>, Field<T5>, Field<T6>, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -73,6 +79,7 @@ public void Iter(delegate*<Iter, Field<T0>, Field<T1>, Field<T2>, Field<T3>, Fie
     public void Iter(delegate*<Iter, Span<T0>, Span<T1>, Span<T2>, Span<T3>, Span<T4>, Span<T5>, Span<T6>, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -83,6 +90,7 @@ public void Iter(delegate*<Iter, Span<T0>, Span<T1>, Span<T2>, Span<T3>, Span<T4
     public void Iter(delegate*<Iter, T0*, T1*, T2*, T3*, T4*, T5*, T6*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -93,6 +101,7 @@ public void Iter(delegate*<Iter, T0*, T1*, T2*, T3*, T4*, T5*, T6*, void> callba
     public void Each(Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5, T6> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -103,6 +112,7 @@ public void Each(Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5, T6> callback)
     public void Each(Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5, T6> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -113,6 +123,7 @@ public void Each(Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5, T6> callback)
     public void Each(Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5, T6> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -123,6 +134,7 @@ public void Each(Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5, T6> callback)
     public void Each(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -133,6 +145,7 @@ public void Each(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T
     public void Each(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -143,6 +156,7 @@ public void Each(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T
     public void Each(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -153,6 +167,7 @@ public void Each(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, re
     public void Each(Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5, T6> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -163,6 +178,7 @@ public void Each(Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5, T6> callback)
     public void Each(Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -173,6 +189,7 @@ public void Each(Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6> callb
     public void Each(Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5, T6> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -183,6 +200,7 @@ public void Each(Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5, T6> callbac
     public void Each(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -193,6 +211,7 @@ public void Each(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, void> callback)
     public void Each(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -203,6 +222,7 @@ public void Each(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, void> call
     public void Each(delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -213,6 +233,7 @@ public void Each(delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, void> c
     public Entity Find(Ecs.FindRefCallback<T0, T1, T2, T3, T4, T5, T6> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -223,6 +244,7 @@ public Entity Find(Ecs.FindRefCallback<T0, T1, T2, T3, T4, T5, T6> callback)
     public Entity Find(Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4, T5, T6> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -233,6 +255,7 @@ public Entity Find(Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4, T5, T6> callbac
     public Entity Find(Ecs.FindIterRefCallback<T0, T1, T2, T3, T4, T5, T6> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -243,6 +266,7 @@ public Entity Find(Ecs.FindIterRefCallback<T0, T1, T2, T3, T4, T5, T6> callback)
     public Entity Find(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -253,6 +277,7 @@ public Entity Find(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref
     public Entity Find(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -263,6 +288,7 @@ public Entity Find(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref
     public Entity Find(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -273,6 +299,7 @@ public Entity Find(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4,
     public Entity Find(Ecs.FindPointerCallback<T0, T1, T2, T3, T4, T5, T6> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -283,6 +310,7 @@ public Entity Find(Ecs.FindPointerCallback<T0, T1, T2, T3, T4, T5, T6> callback)
     public Entity Find(Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -293,6 +321,7 @@ public Entity Find(Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6> cal
     public Entity Find(Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4, T5, T6> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -303,6 +332,7 @@ public Entity Find(Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4, T5, T6> callb
     public Entity Find(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -313,6 +343,7 @@ public Entity Find(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, bool> callback)
     public Entity Find(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -323,6 +354,7 @@ public Entity Find(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, bool> ca
     public Entity Find(delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 }
\ No newline at end of file
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/WorkerIterable/WorkerIterable.IIterable/T8.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/WorkerIterable/WorkerIterable.IIterable/T8.g.cs
index 1214e75f..73041392 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/WorkerIterable/WorkerIterable.IIterable/T8.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/WorkerIterable/WorkerIterable.IIterable/T8.g.cs
@@ -13,6 +13,7 @@ public unsafe partial struct WorkerIterable<T0, T1, T2, T3, T4, T5, T6, T7>
     public void Run(Ecs.RunCallback callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Run(ref this, callback);
     }
 
@@ -23,6 +24,7 @@ public void Run(Ecs.RunCallback callback)
     public void Run(delegate*<Iter, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Run(ref this, callback);
     }
 
@@ -33,6 +35,7 @@ public void Run(delegate*<Iter, void> callback)
     public void Iter(Ecs.IterFieldCallback<T0, T1, T2, T3, T4, T5, T6, T7> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -43,6 +46,7 @@ public void Iter(Ecs.IterFieldCallback<T0, T1, T2, T3, T4, T5, T6, T7> callback)
     public void Iter(Ecs.IterSpanCallback<T0, T1, T2, T3, T4, T5, T6, T7> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -53,6 +57,7 @@ public void Iter(Ecs.IterSpanCallback<T0, T1, T2, T3, T4, T5, T6, T7> callback)
     public void Iter(Ecs.IterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -63,6 +68,7 @@ public void Iter(Ecs.IterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7> callbac
     public void Iter(delegate*<Iter, Field<T0>, Field<T1>, Field<T2>, Field<T3>, Field<T4>, Field<T5>, Field<T6>, Field<T7>, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -73,6 +79,7 @@ public void Iter(delegate*<Iter, Field<T0>, Field<T1>, Field<T2>, Field<T3>, Fie
     public void Iter(delegate*<Iter, Span<T0>, Span<T1>, Span<T2>, Span<T3>, Span<T4>, Span<T5>, Span<T6>, Span<T7>, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -83,6 +90,7 @@ public void Iter(delegate*<Iter, Span<T0>, Span<T1>, Span<T2>, Span<T3>, Span<T4
     public void Iter(delegate*<Iter, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -93,6 +101,7 @@ public void Iter(delegate*<Iter, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, void> c
     public void Each(Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5, T6, T7> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -103,6 +112,7 @@ public void Each(Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5, T6, T7> callback)
     public void Each(Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -113,6 +123,7 @@ public void Each(Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7> callb
     public void Each(Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -123,6 +134,7 @@ public void Each(Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7> callbac
     public void Each(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -133,6 +145,7 @@ public void Each(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T
     public void Each(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -143,6 +156,7 @@ public void Each(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T
     public void Each(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -153,6 +167,7 @@ public void Each(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, re
     public void Each(Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -163,6 +178,7 @@ public void Each(Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7> callbac
     public void Each(Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -173,6 +189,7 @@ public void Each(Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7> c
     public void Each(Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -183,6 +200,7 @@ public void Each(Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7> cal
     public void Each(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -193,6 +211,7 @@ public void Each(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, void> callbac
     public void Each(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -203,6 +222,7 @@ public void Each(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, void>
     public void Each(delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -213,6 +233,7 @@ public void Each(delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, vo
     public Entity Find(Ecs.FindRefCallback<T0, T1, T2, T3, T4, T5, T6, T7> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -223,6 +244,7 @@ public Entity Find(Ecs.FindRefCallback<T0, T1, T2, T3, T4, T5, T6, T7> callback)
     public Entity Find(Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -233,6 +255,7 @@ public Entity Find(Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7> cal
     public Entity Find(Ecs.FindIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -243,6 +266,7 @@ public Entity Find(Ecs.FindIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7> callb
     public Entity Find(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -253,6 +277,7 @@ public Entity Find(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref
     public Entity Find(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -263,6 +288,7 @@ public Entity Find(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref
     public Entity Find(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -273,6 +299,7 @@ public Entity Find(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4,
     public Entity Find(Ecs.FindPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -283,6 +310,7 @@ public Entity Find(Ecs.FindPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7> callb
     public Entity Find(Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -293,6 +321,7 @@ public Entity Find(Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7>
     public Entity Find(Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -303,6 +332,7 @@ public Entity Find(Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7> c
     public Entity Find(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -313,6 +343,7 @@ public Entity Find(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, bool> callb
     public Entity Find(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -323,6 +354,7 @@ public Entity Find(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, boo
     public Entity Find(delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 }
\ No newline at end of file
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/WorkerIterable/WorkerIterable.IIterable/T9.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/WorkerIterable/WorkerIterable.IIterable/T9.g.cs
index 46cb4f3a..87046663 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/WorkerIterable/WorkerIterable.IIterable/T9.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/WorkerIterable/WorkerIterable.IIterable/T9.g.cs
@@ -13,6 +13,7 @@ public unsafe partial struct WorkerIterable<T0, T1, T2, T3, T4, T5, T6, T7, T8>
     public void Run(Ecs.RunCallback callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Run(ref this, callback);
     }
 
@@ -23,6 +24,7 @@ public void Run(Ecs.RunCallback callback)
     public void Run(delegate*<Iter, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Run(ref this, callback);
     }
 
@@ -33,6 +35,7 @@ public void Run(delegate*<Iter, void> callback)
     public void Iter(Ecs.IterFieldCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -43,6 +46,7 @@ public void Iter(Ecs.IterFieldCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> callb
     public void Iter(Ecs.IterSpanCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -53,6 +57,7 @@ public void Iter(Ecs.IterSpanCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> callba
     public void Iter(Ecs.IterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -63,6 +68,7 @@ public void Iter(Ecs.IterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> cal
     public void Iter(delegate*<Iter, Field<T0>, Field<T1>, Field<T2>, Field<T3>, Field<T4>, Field<T5>, Field<T6>, Field<T7>, Field<T8>, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -73,6 +79,7 @@ public void Iter(delegate*<Iter, Field<T0>, Field<T1>, Field<T2>, Field<T3>, Fie
     public void Iter(delegate*<Iter, Span<T0>, Span<T1>, Span<T2>, Span<T3>, Span<T4>, Span<T5>, Span<T6>, Span<T7>, Span<T8>, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -83,6 +90,7 @@ public void Iter(delegate*<Iter, Span<T0>, Span<T1>, Span<T2>, Span<T3>, Span<T4
     public void Iter(delegate*<Iter, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), false);
         Invoker.Iter(ref this, callback);
     }
 
@@ -93,6 +101,7 @@ public void Iter(delegate*<Iter, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, vo
     public void Each(Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -103,6 +112,7 @@ public void Each(Ecs.EachRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> callbac
     public void Each(Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -113,6 +123,7 @@ public void Each(Ecs.EachEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> c
     public void Each(Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -123,6 +134,7 @@ public void Each(Ecs.EachIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> cal
     public void Each(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -133,6 +145,7 @@ public void Each(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T
     public void Each(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -143,6 +156,7 @@ public void Each(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T
     public void Each(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -153,6 +167,7 @@ public void Each(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, re
     public void Each(Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -163,6 +178,7 @@ public void Each(Ecs.EachPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> cal
     public void Each(Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -173,6 +189,7 @@ public void Each(Ecs.EachEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T
     public void Each(Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -183,6 +200,7 @@ public void Each(Ecs.EachIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8>
     public void Each(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -193,6 +211,7 @@ public void Each(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, void> ca
     public void Each(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -203,6 +222,7 @@ public void Each(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*,
     public void Each(delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, void> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         Invoker.Each(ref this, callback);
     }
 
@@ -213,6 +233,7 @@ public void Each(delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8
     public Entity Find(Ecs.FindRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -223,6 +244,7 @@ public Entity Find(Ecs.FindRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> callb
     public Entity Find(Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -233,6 +255,7 @@ public Entity Find(Ecs.FindEntityRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8>
     public Entity Find(Ecs.FindIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -243,6 +266,7 @@ public Entity Find(Ecs.FindIterRefCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> c
     public Entity Find(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -253,6 +277,7 @@ public Entity Find(delegate*<ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref
     public Entity Find(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -263,6 +288,7 @@ public Entity Find(delegate*<Entity, ref T0, ref T1, ref T2, ref T3, ref T4, ref
     public Entity Find(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4, ref T5, ref T6, ref T7, ref T8, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertReferenceTypes(true);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -273,6 +299,7 @@ public Entity Find(delegate*<Iter, int, ref T0, ref T1, ref T2, ref T3, ref T4,
     public Entity Find(Ecs.FindPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -283,6 +310,7 @@ public Entity Find(Ecs.FindPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> c
     public Entity Find(Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -293,6 +321,7 @@ public Entity Find(Ecs.FindEntityPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7,
     public Entity Find(Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T8> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -303,6 +332,7 @@ public Entity Find(Ecs.FindIterPointerCallback<T0, T1, T2, T3, T4, T5, T6, T7, T
     public Entity Find(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -313,6 +343,7 @@ public Entity Find(delegate*<T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, bool>
     public Entity Find(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 
@@ -323,6 +354,7 @@ public Entity Find(delegate*<Entity, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*
     public Entity Find(delegate*<Iter, int, T0*, T1*, T2*, T3*, T4*, T5*, T6*, T7*, T8*, bool> callback)
     {
         TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertReferenceTypes(false);
+        TypeHelper<T0, T1, T2, T3, T4, T5, T6, T7, T8>.AssertSparseTypes(Ecs.GetIterableWorld(ref this), true);
         return Invoker.Find(ref this, callback);
     }
 }
\ No newline at end of file
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/WorkerIterable/WorkerIterable/T1.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/WorkerIterable/WorkerIterable/T1.g.cs
index 155ccd55..f7e90538 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/WorkerIterable/WorkerIterable/T1.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/WorkerIterable/WorkerIterable/T1.g.cs
@@ -63,6 +63,9 @@ public override int GetHashCode()
 // IIterableBase Interface
 public unsafe partial struct WorkerIterable<T0> : IIterableBase
 {
+    /// <inheritdoc cref="WorkerIterable.World"/>
+    public ref ecs_world_t* World => ref _workerIterable.World;
+    
     /// <inheritdoc cref="WorkerIterable.GetIter(ecs_world_t*)"/>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public ecs_iter_t GetIter(ecs_world_t* world = null)
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/WorkerIterable/WorkerIterable/T10.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/WorkerIterable/WorkerIterable/T10.g.cs
index 42dc5f39..a17dff08 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/WorkerIterable/WorkerIterable/T10.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/WorkerIterable/WorkerIterable/T10.g.cs
@@ -63,6 +63,9 @@ public override int GetHashCode()
 // IIterableBase Interface
 public unsafe partial struct WorkerIterable<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> : IIterableBase
 {
+    /// <inheritdoc cref="WorkerIterable.World"/>
+    public ref ecs_world_t* World => ref _workerIterable.World;
+    
     /// <inheritdoc cref="WorkerIterable.GetIter(ecs_world_t*)"/>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public ecs_iter_t GetIter(ecs_world_t* world = null)
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/WorkerIterable/WorkerIterable/T11.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/WorkerIterable/WorkerIterable/T11.g.cs
index edd77bac..c1ba9880 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/WorkerIterable/WorkerIterable/T11.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/WorkerIterable/WorkerIterable/T11.g.cs
@@ -63,6 +63,9 @@ public override int GetHashCode()
 // IIterableBase Interface
 public unsafe partial struct WorkerIterable<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> : IIterableBase
 {
+    /// <inheritdoc cref="WorkerIterable.World"/>
+    public ref ecs_world_t* World => ref _workerIterable.World;
+    
     /// <inheritdoc cref="WorkerIterable.GetIter(ecs_world_t*)"/>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public ecs_iter_t GetIter(ecs_world_t* world = null)
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/WorkerIterable/WorkerIterable/T12.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/WorkerIterable/WorkerIterable/T12.g.cs
index 8b288592..82cb8a78 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/WorkerIterable/WorkerIterable/T12.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/WorkerIterable/WorkerIterable/T12.g.cs
@@ -63,6 +63,9 @@ public override int GetHashCode()
 // IIterableBase Interface
 public unsafe partial struct WorkerIterable<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> : IIterableBase
 {
+    /// <inheritdoc cref="WorkerIterable.World"/>
+    public ref ecs_world_t* World => ref _workerIterable.World;
+    
     /// <inheritdoc cref="WorkerIterable.GetIter(ecs_world_t*)"/>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public ecs_iter_t GetIter(ecs_world_t* world = null)
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/WorkerIterable/WorkerIterable/T13.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/WorkerIterable/WorkerIterable/T13.g.cs
index 81b44030..6b1cbb8b 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/WorkerIterable/WorkerIterable/T13.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/WorkerIterable/WorkerIterable/T13.g.cs
@@ -63,6 +63,9 @@ public override int GetHashCode()
 // IIterableBase Interface
 public unsafe partial struct WorkerIterable<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> : IIterableBase
 {
+    /// <inheritdoc cref="WorkerIterable.World"/>
+    public ref ecs_world_t* World => ref _workerIterable.World;
+    
     /// <inheritdoc cref="WorkerIterable.GetIter(ecs_world_t*)"/>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public ecs_iter_t GetIter(ecs_world_t* world = null)
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/WorkerIterable/WorkerIterable/T14.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/WorkerIterable/WorkerIterable/T14.g.cs
index fb34d14d..1046e342 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/WorkerIterable/WorkerIterable/T14.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/WorkerIterable/WorkerIterable/T14.g.cs
@@ -63,6 +63,9 @@ public override int GetHashCode()
 // IIterableBase Interface
 public unsafe partial struct WorkerIterable<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> : IIterableBase
 {
+    /// <inheritdoc cref="WorkerIterable.World"/>
+    public ref ecs_world_t* World => ref _workerIterable.World;
+    
     /// <inheritdoc cref="WorkerIterable.GetIter(ecs_world_t*)"/>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public ecs_iter_t GetIter(ecs_world_t* world = null)
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/WorkerIterable/WorkerIterable/T15.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/WorkerIterable/WorkerIterable/T15.g.cs
index e4f6bdd6..1531d98a 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/WorkerIterable/WorkerIterable/T15.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/WorkerIterable/WorkerIterable/T15.g.cs
@@ -63,6 +63,9 @@ public override int GetHashCode()
 // IIterableBase Interface
 public unsafe partial struct WorkerIterable<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> : IIterableBase
 {
+    /// <inheritdoc cref="WorkerIterable.World"/>
+    public ref ecs_world_t* World => ref _workerIterable.World;
+    
     /// <inheritdoc cref="WorkerIterable.GetIter(ecs_world_t*)"/>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public ecs_iter_t GetIter(ecs_world_t* world = null)
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/WorkerIterable/WorkerIterable/T16.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/WorkerIterable/WorkerIterable/T16.g.cs
index eb43532a..27adf083 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/WorkerIterable/WorkerIterable/T16.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/WorkerIterable/WorkerIterable/T16.g.cs
@@ -63,6 +63,9 @@ public override int GetHashCode()
 // IIterableBase Interface
 public unsafe partial struct WorkerIterable<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> : IIterableBase
 {
+    /// <inheritdoc cref="WorkerIterable.World"/>
+    public ref ecs_world_t* World => ref _workerIterable.World;
+    
     /// <inheritdoc cref="WorkerIterable.GetIter(ecs_world_t*)"/>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public ecs_iter_t GetIter(ecs_world_t* world = null)
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/WorkerIterable/WorkerIterable/T2.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/WorkerIterable/WorkerIterable/T2.g.cs
index 780c8f71..8a3a6011 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/WorkerIterable/WorkerIterable/T2.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/WorkerIterable/WorkerIterable/T2.g.cs
@@ -63,6 +63,9 @@ public override int GetHashCode()
 // IIterableBase Interface
 public unsafe partial struct WorkerIterable<T0, T1> : IIterableBase
 {
+    /// <inheritdoc cref="WorkerIterable.World"/>
+    public ref ecs_world_t* World => ref _workerIterable.World;
+    
     /// <inheritdoc cref="WorkerIterable.GetIter(ecs_world_t*)"/>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public ecs_iter_t GetIter(ecs_world_t* world = null)
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/WorkerIterable/WorkerIterable/T3.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/WorkerIterable/WorkerIterable/T3.g.cs
index 160fbb60..a1f0cb71 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/WorkerIterable/WorkerIterable/T3.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/WorkerIterable/WorkerIterable/T3.g.cs
@@ -63,6 +63,9 @@ public override int GetHashCode()
 // IIterableBase Interface
 public unsafe partial struct WorkerIterable<T0, T1, T2> : IIterableBase
 {
+    /// <inheritdoc cref="WorkerIterable.World"/>
+    public ref ecs_world_t* World => ref _workerIterable.World;
+    
     /// <inheritdoc cref="WorkerIterable.GetIter(ecs_world_t*)"/>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public ecs_iter_t GetIter(ecs_world_t* world = null)
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/WorkerIterable/WorkerIterable/T4.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/WorkerIterable/WorkerIterable/T4.g.cs
index 31c33402..c41c52c4 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/WorkerIterable/WorkerIterable/T4.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/WorkerIterable/WorkerIterable/T4.g.cs
@@ -63,6 +63,9 @@ public override int GetHashCode()
 // IIterableBase Interface
 public unsafe partial struct WorkerIterable<T0, T1, T2, T3> : IIterableBase
 {
+    /// <inheritdoc cref="WorkerIterable.World"/>
+    public ref ecs_world_t* World => ref _workerIterable.World;
+    
     /// <inheritdoc cref="WorkerIterable.GetIter(ecs_world_t*)"/>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public ecs_iter_t GetIter(ecs_world_t* world = null)
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/WorkerIterable/WorkerIterable/T5.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/WorkerIterable/WorkerIterable/T5.g.cs
index cf5501c1..4196b7d9 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/WorkerIterable/WorkerIterable/T5.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/WorkerIterable/WorkerIterable/T5.g.cs
@@ -63,6 +63,9 @@ public override int GetHashCode()
 // IIterableBase Interface
 public unsafe partial struct WorkerIterable<T0, T1, T2, T3, T4> : IIterableBase
 {
+    /// <inheritdoc cref="WorkerIterable.World"/>
+    public ref ecs_world_t* World => ref _workerIterable.World;
+    
     /// <inheritdoc cref="WorkerIterable.GetIter(ecs_world_t*)"/>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public ecs_iter_t GetIter(ecs_world_t* world = null)
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/WorkerIterable/WorkerIterable/T6.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/WorkerIterable/WorkerIterable/T6.g.cs
index df596c9a..21bbb8c9 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/WorkerIterable/WorkerIterable/T6.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/WorkerIterable/WorkerIterable/T6.g.cs
@@ -63,6 +63,9 @@ public override int GetHashCode()
 // IIterableBase Interface
 public unsafe partial struct WorkerIterable<T0, T1, T2, T3, T4, T5> : IIterableBase
 {
+    /// <inheritdoc cref="WorkerIterable.World"/>
+    public ref ecs_world_t* World => ref _workerIterable.World;
+    
     /// <inheritdoc cref="WorkerIterable.GetIter(ecs_world_t*)"/>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public ecs_iter_t GetIter(ecs_world_t* world = null)
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/WorkerIterable/WorkerIterable/T7.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/WorkerIterable/WorkerIterable/T7.g.cs
index 42d8ac93..1e8b45dc 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/WorkerIterable/WorkerIterable/T7.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/WorkerIterable/WorkerIterable/T7.g.cs
@@ -63,6 +63,9 @@ public override int GetHashCode()
 // IIterableBase Interface
 public unsafe partial struct WorkerIterable<T0, T1, T2, T3, T4, T5, T6> : IIterableBase
 {
+    /// <inheritdoc cref="WorkerIterable.World"/>
+    public ref ecs_world_t* World => ref _workerIterable.World;
+    
     /// <inheritdoc cref="WorkerIterable.GetIter(ecs_world_t*)"/>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public ecs_iter_t GetIter(ecs_world_t* world = null)
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/WorkerIterable/WorkerIterable/T8.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/WorkerIterable/WorkerIterable/T8.g.cs
index d074787b..a55b54d7 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/WorkerIterable/WorkerIterable/T8.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/WorkerIterable/WorkerIterable/T8.g.cs
@@ -63,6 +63,9 @@ public override int GetHashCode()
 // IIterableBase Interface
 public unsafe partial struct WorkerIterable<T0, T1, T2, T3, T4, T5, T6, T7> : IIterableBase
 {
+    /// <inheritdoc cref="WorkerIterable.World"/>
+    public ref ecs_world_t* World => ref _workerIterable.World;
+    
     /// <inheritdoc cref="WorkerIterable.GetIter(ecs_world_t*)"/>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public ecs_iter_t GetIter(ecs_world_t* world = null)
diff --git a/src/Flecs.NET/Generated/Flecs.NET.Codegen/WorkerIterable/WorkerIterable/T9.g.cs b/src/Flecs.NET/Generated/Flecs.NET.Codegen/WorkerIterable/WorkerIterable/T9.g.cs
index 7fb3003d..db807850 100644
--- a/src/Flecs.NET/Generated/Flecs.NET.Codegen/WorkerIterable/WorkerIterable/T9.g.cs
+++ b/src/Flecs.NET/Generated/Flecs.NET.Codegen/WorkerIterable/WorkerIterable/T9.g.cs
@@ -63,6 +63,9 @@ public override int GetHashCode()
 // IIterableBase Interface
 public unsafe partial struct WorkerIterable<T0, T1, T2, T3, T4, T5, T6, T7, T8> : IIterableBase
 {
+    /// <inheritdoc cref="WorkerIterable.World"/>
+    public ref ecs_world_t* World => ref _workerIterable.World;
+    
     /// <inheritdoc cref="WorkerIterable.GetIter(ecs_world_t*)"/>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public ecs_iter_t GetIter(ecs_world_t* world = null)
diff --git a/src/Flecs.NET/Utilities/Utils.cs b/src/Flecs.NET/Utilities/Utils.cs
index 80981b8e..8388daa1 100644
--- a/src/Flecs.NET/Utilities/Utils.cs
+++ b/src/Flecs.NET/Utilities/Utils.cs
@@ -42,47 +42,42 @@ public static bool Bool(byte value)
     }
 
     /// <summary>
-    ///     Gets the next power of 2 for the provided number.
+    ///     Checks if specific bit is set.
     /// </summary>
-    /// <param name="num"></param>
     /// <returns></returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static int NextPowOf2(int num)
+    public static bool IsBitSet(int value, int index)
     {
-        num--;
-        num |= num >> 1;
-        num |= num >> 2;
-        num |= num >> 4;
-        num |= num >> 8;
-        num |= num >> 16;
-        num++;
-
-        return num;
+        return (value & (1 << index)) != 0;
     }
 
     /// <summary>
-    ///     Tests if 2 readonly refs point to the same object.
+    ///     Checks if specific bit is set.
     /// </summary>
-    /// <param name="a"></param>
-    /// <param name="b"></param>
-    /// <typeparam name="T"></typeparam>
     /// <returns></returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static bool AreSameReadOnlyRefs<T>(in T a, in T b)
+    public static bool IsBitSet(uint value, int index)
     {
-        return Unsafe.AreSame(ref Unsafe.AsRef(in a), ref Unsafe.AsRef(in b));
+        return (value & (1 << index)) != 0;
     }
 
     /// <summary>
-    ///     Tests if a readonly ref is null.
+    ///     Gets the next power of 2 for the provided number.
     /// </summary>
-    /// <param name="obj"></param>
-    /// <typeparam name="T"></typeparam>
+    /// <param name="num"></param>
     /// <returns></returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static bool IsNullReadOnlyRef<T>(in T obj)
+    public static int NextPowOf2(int num)
     {
-        return Unsafe.IsNullRef(ref Unsafe.AsRef(in obj));
+        num--;
+        num |= num >> 1;
+        num |= num >> 2;
+        num |= num >> 4;
+        num |= num >> 8;
+        num |= num >> 16;
+        num++;
+
+        return num;
     }
 
     /// <summary>
@@ -106,4 +101,4 @@ public static void OsFree(void* data)
     {
         OsFree((IntPtr)data);
     }
-}
\ No newline at end of file
+}
diff --git a/submodules/flecs b/submodules/flecs
index 1af6e06b..02c8c266 160000
--- a/submodules/flecs
+++ b/submodules/flecs
@@ -1 +1 @@
-Subproject commit 1af6e06b6b5a220c5ea061ae448bc77494d085e1
+Subproject commit 02c8c2666b22ccce5706c8f16efaf813704fe31e