diff --git a/src/ECS.Boost/Chunk/Extensions.6.cs b/src/ECS.Boost/Chunk/Extensions.6.cs
new file mode 100644
index 000000000..1626bd13f
--- /dev/null
+++ b/src/ECS.Boost/Chunk/Extensions.6.cs
@@ -0,0 +1,86 @@
+// Copyright (c) Ullrich Praetz - https://github.com/friflo. All rights reserved.
+// See LICENSE file in the project root for full license information.
+
+using System;
+
+// ReSharper disable once CheckNamespace
+namespace Friflo.Engine.ECS;
+
+public static partial class ChunkExtensions
+{
+    public static void Each<TEach, T1,T2,T3,T4,T5,T6>(this Chunks<T1,T2,T3,T4,T5,T6> chunks, ref TEach each)
+        where TEach : IEach<T1, T2, T3, T4, T5, T6 >
+        where T1 : struct
+        where T2 : struct
+        where T3 : struct
+        where T4 : struct
+        where T5 : struct
+        where T6 : struct
+    {
+        var entities    = chunks.Entities;
+        var start       = entities.Start;
+        var length      = entities.Length;
+        var span1       = new Span<T1>(chunks.Chunk1.ArchetypeComponents, start, length);
+        var span2       = new Span<T2>(chunks.Chunk2.ArchetypeComponents, start, length);
+        var span3       = new Span<T3>(chunks.Chunk3.ArchetypeComponents, start, length);
+        var span4       = new Span<T4>(chunks.Chunk4.ArchetypeComponents, start, length);
+        var span5       = new Span<T5>(chunks.Chunk5.ArchetypeComponents, start, length);
+        var span6       = new Span<T6>(chunks.Chunk6.ArchetypeComponents, start, length);
+        
+        unsafe {
+#pragma warning disable CS8500
+            fixed (T1*  c1  = span1)
+            fixed (T2*  c2  = span2)
+            fixed (T3*  c3  = span3)
+            fixed (T4*  c4  = span4)
+            fixed (T5*  c5  = span5)
+            fixed (T6*  c6  = span6)
+#pragma warning restore CS8500
+            {
+                for (int i = 0; i < length; i++) {
+                    // all spanX.Length == length. spanX[i] is always in bounds.
+                    each.Execute(ref c1[i], ref c2[i], ref c3[i], ref c4[i], ref c5[i], ref c6[i]);
+                }
+            }
+        }
+    }
+    
+    public static void EachEntity<TEachEntity, T1,T2,T3,T4,T5,T6>(this Chunks<T1,T2,T3,T4,T5,T6> chunks, ref TEachEntity each)
+        where TEachEntity : IEachEntity<T1, T2, T3, T4, T5, T6>
+        where T1 : struct
+        where T2 : struct
+        where T3 : struct
+        where T4 : struct
+        where T5 : struct
+        where T6 : struct
+    {
+        var entities    = chunks.Entities;
+        var start       = entities.Start;
+        var length      = entities.Length;
+        var spanIds     = entities.Archetype.EntityIds.Slice             (start, length);
+        var span1       = new Span<T1>(chunks.Chunk1.ArchetypeComponents, start, length);
+        var span2       = new Span<T2>(chunks.Chunk2.ArchetypeComponents, start, length);
+        var span3       = new Span<T3>(chunks.Chunk3.ArchetypeComponents, start, length);
+        var span4       = new Span<T4>(chunks.Chunk4.ArchetypeComponents, start, length);
+        var span5       = new Span<T5>(chunks.Chunk5.ArchetypeComponents, start, length);
+        var span6       = new Span<T6>(chunks.Chunk6.ArchetypeComponents, start, length);
+        
+        unsafe {
+#pragma warning disable CS8500
+            fixed (T1*  c1  = span1)
+            fixed (T2*  c2  = span2)
+            fixed (T3*  c3  = span3)
+            fixed (T4*  c4  = span4)
+            fixed (T5*  c5  = span5)
+            fixed (T6*  c6  = span6)
+#pragma warning restore CS8500
+            fixed (int* ids = spanIds)
+            {
+                for (int i = 0; i < length; i++) {
+                    // all spanX.Length == length. spanX[i] is always in bounds.  
+                    each.Execute(ref c1[i], ref c2[i], ref c3[i], ref c4[i], ref c5[i], ref c6[i], ids[i]);
+                }
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/ECS.Boost/Chunk/Extensions.7.cs b/src/ECS.Boost/Chunk/Extensions.7.cs
new file mode 100644
index 000000000..1bbd67262
--- /dev/null
+++ b/src/ECS.Boost/Chunk/Extensions.7.cs
@@ -0,0 +1,92 @@
+// Copyright (c) Ullrich Praetz - https://github.com/friflo. All rights reserved.
+// See LICENSE file in the project root for full license information.
+
+using System;
+
+// ReSharper disable once CheckNamespace
+namespace Friflo.Engine.ECS;
+
+public static partial class ChunkExtensions
+{
+    public static void Each<TEach, T1,T2,T3,T4,T5,T6,T7>(this Chunks<T1,T2,T3,T4,T5,T6,T7> chunks, ref TEach each)
+        where TEach : IEach<T1, T2, T3, T4, T5, T6, T7>
+        where T1 : struct
+        where T2 : struct
+        where T3 : struct
+        where T4 : struct
+        where T5 : struct
+        where T6 : struct
+        where T7 : struct
+    {
+        var entities    = chunks.Entities;
+        var start       = entities.Start;
+        var length      = entities.Length;
+        var span1       = new Span<T1>(chunks.Chunk1.ArchetypeComponents, start, length);
+        var span2       = new Span<T2>(chunks.Chunk2.ArchetypeComponents, start, length);
+        var span3       = new Span<T3>(chunks.Chunk3.ArchetypeComponents, start, length);
+        var span4       = new Span<T4>(chunks.Chunk4.ArchetypeComponents, start, length);
+        var span5       = new Span<T5>(chunks.Chunk5.ArchetypeComponents, start, length);
+        var span6       = new Span<T6>(chunks.Chunk6.ArchetypeComponents, start, length);
+        var span7       = new Span<T7>(chunks.Chunk7.ArchetypeComponents, start, length);
+        
+        unsafe {
+#pragma warning disable CS8500
+            fixed (T1*  c1  = span1)
+            fixed (T2*  c2  = span2)
+            fixed (T3*  c3  = span3)
+            fixed (T4*  c4  = span4)
+            fixed (T5*  c5  = span5)
+            fixed (T6*  c6  = span6)
+            fixed (T7*  c7  = span7)
+#pragma warning restore CS8500
+            {
+                for (int i = 0; i < length; i++) {
+                    // all spanX.Length == length. spanX[i] is always in bounds.
+                    each.Execute(ref c1[i], ref c2[i], ref c3[i], ref c4[i], ref c5[i], ref c6[i], ref c7[i]);
+                }
+            }
+        }
+    }
+    
+    public static void EachEntity<TEachEntity, T1,T2,T3,T4,T5,T6,T7>(this Chunks<T1,T2,T3,T4,T5,T6,T7> chunks, ref TEachEntity each)
+        where TEachEntity : IEachEntity<T1, T2, T3, T4, T5, T6, T7>
+        where T1 : struct
+        where T2 : struct
+        where T3 : struct
+        where T4 : struct
+        where T5 : struct
+        where T6 : struct
+        where T7 : struct
+    {
+        var entities    = chunks.Entities;
+        var start       = entities.Start;
+        var length      = entities.Length;
+        var spanIds     = entities.Archetype.EntityIds.Slice             (start, length);
+        var span1       = new Span<T1>(chunks.Chunk1.ArchetypeComponents, start, length);
+        var span2       = new Span<T2>(chunks.Chunk2.ArchetypeComponents, start, length);
+        var span3       = new Span<T3>(chunks.Chunk3.ArchetypeComponents, start, length);
+        var span4       = new Span<T4>(chunks.Chunk4.ArchetypeComponents, start, length);
+        var span5       = new Span<T5>(chunks.Chunk5.ArchetypeComponents, start, length);
+        var span6       = new Span<T6>(chunks.Chunk6.ArchetypeComponents, start, length);
+        var span7       = new Span<T7>(chunks.Chunk7.ArchetypeComponents, start, length);
+        
+        unsafe {
+#pragma warning disable CS8500
+            fixed (T1*  c1  = span1)
+            fixed (T2*  c2  = span2)
+            fixed (T3*  c3  = span3)
+            fixed (T4*  c4  = span4)
+            fixed (T5*  c5  = span5)
+            fixed (T6*  c6  = span6)
+            fixed (T7*  c7  = span7)
+#pragma warning restore CS8500
+            fixed (int* ids = spanIds)
+            {
+                for (int i = 0; i < length; i++) {
+                    // all spanX.Length == length. spanX[i] is always in bounds.  
+                    each.Execute(ref c1[i], ref c2[i], ref c3[i], ref c4[i], ref c5[i], ref c6[i], ref c7[i], ids[i]);
+                }
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/ECS.Boost/Query/Extensions.6.cs b/src/ECS.Boost/Query/Extensions.6.cs
new file mode 100644
index 000000000..06a53af51
--- /dev/null
+++ b/src/ECS.Boost/Query/Extensions.6.cs
@@ -0,0 +1,38 @@
+// Copyright (c) Ullrich Praetz - https://github.com/friflo. All rights reserved.
+// See LICENSE file in the project root for full license information.
+
+// ReSharper disable once CheckNamespace
+namespace Friflo.Engine.ECS;
+
+public static partial class QueryExtensions
+{
+    public static TEach Each<TEach, T1,T2,T3,T4,T5,T6>(this ArchetypeQuery<T1,T2,T3,T4,T5,T6> query, TEach each)
+        where TEach : IEach<T1, T2, T3, T4, T5,T6>
+        where T1 : struct
+        where T2 : struct
+        where T3 : struct
+        where T4 : struct
+        where T5 : struct
+        where T6 : struct
+    {
+        foreach (var chunk in query.Chunks) {
+            chunk.Each(ref each);
+        }
+        return each;
+    }
+    
+    public static TEachEntity EachEntity<TEachEntity, T1,T2,T3,T4,T5,T6>(this ArchetypeQuery<T1,T2,T3,T4,T5,T6> query, TEachEntity each)
+        where TEachEntity : IEachEntity<T1, T2, T3, T4, T5, T6>
+        where T1 : struct
+        where T2 : struct
+        where T3 : struct
+        where T4 : struct
+        where T5 : struct
+        where T6 : struct
+    {
+        foreach (var chunk in query.Chunks) {
+            chunk.EachEntity(ref each);
+        }
+        return each;
+    }
+}
\ No newline at end of file
diff --git a/src/ECS.Boost/Query/Extensions.7.cs b/src/ECS.Boost/Query/Extensions.7.cs
new file mode 100644
index 000000000..6e224212a
--- /dev/null
+++ b/src/ECS.Boost/Query/Extensions.7.cs
@@ -0,0 +1,40 @@
+// Copyright (c) Ullrich Praetz - https://github.com/friflo. All rights reserved.
+// See LICENSE file in the project root for full license information.
+
+// ReSharper disable once CheckNamespace
+namespace Friflo.Engine.ECS;
+
+public static partial class QueryExtensions
+{
+    public static TEach Each<TEach, T1,T2,T3,T4,T5,T6,T7>(this ArchetypeQuery<T1,T2,T3,T4,T5,T6,T7> query, TEach each)
+        where TEach : IEach<T1, T2, T3, T4, T5,T6,T7>
+        where T1 : struct
+        where T2 : struct
+        where T3 : struct
+        where T4 : struct
+        where T5 : struct
+        where T6 : struct
+        where T7 : struct
+    {
+        foreach (var chunk in query.Chunks) {
+            chunk.Each(ref each);
+        }
+        return each;
+    }
+    
+    public static TEachEntity EachEntity<TEachEntity, T1,T2,T3,T4,T5,T6,T7>(this ArchetypeQuery<T1,T2,T3,T4,T5,T6,T7> query, TEachEntity each)
+        where TEachEntity : IEachEntity<T1, T2, T3, T4, T5, T6,T7>
+        where T1 : struct
+        where T2 : struct
+        where T3 : struct
+        where T4 : struct
+        where T5 : struct
+        where T6 : struct
+        where T7 : struct
+    {
+        foreach (var chunk in query.Chunks) {
+            chunk.EachEntity(ref each);
+        }
+        return each;
+    }
+}
\ No newline at end of file
diff --git a/src/ECS/Archetype/ComponentTypes.cs b/src/ECS/Archetype/ComponentTypes.cs
index 00f1b344e..4d0837e99 100644
--- a/src/ECS/Archetype/ComponentTypes.cs
+++ b/src/ECS/Archetype/ComponentTypes.cs
@@ -68,8 +68,12 @@ internal ComponentTypes(in SignatureIndexes indexes)
             case 3: goto Type3;
             case 4: goto Type4;
             case 5: goto Type5;
+            case 6: goto Type6;
+            case 7: goto Type7;
             default: throw new IndexOutOfRangeException(); // unreachable - already ensured at SignatureIndexes
         }
+        Type7:   bitSet.SetBit(indexes.T7);
+        Type6:   bitSet.SetBit(indexes.T6);
         Type5:   bitSet.SetBit(indexes.T5);
         Type4:   bitSet.SetBit(indexes.T4);
         Type3:   bitSet.SetBit(indexes.T3);
@@ -315,7 +319,7 @@ public static ComponentTypes Get<T1, T2, T3, T4>()
     
     /// <summary>
     /// Create an instance containing the passed <see cref="IComponent"/> types <typeparamref name="T1"/>,
-    /// <typeparamref name="T2"/>, <typeparamref name="T3"/>, <typeparamref name="T4"/>  and <typeparamref name="T4"/>.
+    /// <typeparamref name="T2"/>, <typeparamref name="T3"/>, <typeparamref name="T4"/>  and <typeparamref name="T5"/>.
     /// </summary>
     public static ComponentTypes Get<T1, T2, T3, T4, T5>()
         where T1 : struct, IComponent
@@ -326,52 +330,19 @@ public static ComponentTypes Get<T1, T2, T3, T4, T5>()
     {
         return Generic<T1,T2,T3,T4,T5>.ComponentTypes;
     }
-    /*
-    internal static ComponentTypes Get<T1, T2, T3, T4, T5, T6>()
-        where T1 : struct, IComponent
-        where T2 : struct, IComponent
-        where T3 : struct, IComponent
-        where T4 : struct, IComponent
-        where T5 : struct, IComponent
-        where T6 : struct, IComponent
-    {
-        return new ComponentTypes(
-            StructInfo<T1>.Index,
-            StructInfo<T2>.Index,
-            StructInfo<T3>.Index,
-            StructInfo<T4>.Index,
-            StructInfo<T5>.Index,
-            StructInfo<T6>.Index);
-    }
-    
-    internal static ComponentTypes Get<T1, T2, T3, T4, T5, T6, T7>()
-        where T1 : struct, IComponent
-        where T2 : struct, IComponent
-        where T3 : struct, IComponent
-        where T4 : struct, IComponent
-        where T5 : struct, IComponent
-        where T6 : struct, IComponent
-        where T7 : struct, IComponent
-    {
-        return new ComponentTypes(
-            StructInfo<T1>.Index,
-            StructInfo<T2>.Index,
-            StructInfo<T3>.Index,
-            StructInfo<T4>.Index,
-            StructInfo<T5>.Index,
-            StructInfo<T6>.Index,
-            StructInfo<T7>.Index);
-    }
     
-    internal static ComponentTypes Get<T1, T2, T3, T4, T5, T6, T7, T8>()
+    /// <summary>
+    /// Create an instance containing the passed <see cref="IComponent"/> types <typeparamref name="T1"/>,
+    /// <typeparamref name="T2"/>, <typeparamref name="T3"/>, <typeparamref name="T4"/>, <typeparamref name="T5"/>
+    /// and <typeparamref name="T6"/>.
+    /// </summary>
+    public static ComponentTypes Get<T1, T2, T3, T4, T5, T6>()
         where T1 : struct, IComponent
         where T2 : struct, IComponent
         where T3 : struct, IComponent
         where T4 : struct, IComponent
         where T5 : struct, IComponent
         where T6 : struct, IComponent
-        where T7 : struct, IComponent
-        where T8 : struct, IComponent
     {
         return new ComponentTypes(
             StructInfo<T1>.Index,
@@ -379,58 +350,102 @@ internal static ComponentTypes Get<T1, T2, T3, T4, T5, T6, T7, T8>()
             StructInfo<T3>.Index,
             StructInfo<T4>.Index,
             StructInfo<T5>.Index,
-            StructInfo<T6>.Index,
-            StructInfo<T7>.Index,
-            StructInfo<T8>.Index);
+            StructInfo<T6>.Index);
     }
     
-    internal static ComponentTypes Get<T1, T2, T3, T4, T5, T6, T7, T8, T9>()
-        where T1 : struct, IComponent
-        where T2 : struct, IComponent
-        where T3 : struct, IComponent
-        where T4 : struct, IComponent
-        where T5 : struct, IComponent
-        where T6 : struct, IComponent
-        where T7 : struct, IComponent
-        where T8 : struct, IComponent
-        where T9 : struct, IComponent
-    {
-        return new ComponentTypes(
-            StructInfo<T1>.Index,
-            StructInfo<T2>.Index,
-            StructInfo<T3>.Index,
-            StructInfo<T4>.Index,
-            StructInfo<T5>.Index,
-            StructInfo<T6>.Index,
-            StructInfo<T7>.Index,
-            StructInfo<T8>.Index,
-            StructInfo<T9>.Index);
-    }
+    /// <summary>
+    /// Create an instance containing the passed <see cref="IComponent"/> types <typeparamref name="T1"/>,
+    /// <typeparamref name="T2"/>, <typeparamref name="T3"/>, <typeparamref name="T4"/>, <typeparamref name="T5"/>,
+    /// <typeparamref name="T6"/>  and <typeparamref name="T7"/>.
+    /// </summary>
+    public static ComponentTypes Get<T1, T2, T3, T4, T5, T6, T7>()
+         where T1 : struct, IComponent
+         where T2 : struct, IComponent
+         where T3 : struct, IComponent
+         where T4 : struct, IComponent
+         where T5 : struct, IComponent
+         where T6 : struct, IComponent
+         where T7 : struct, IComponent
+     {
+         return new ComponentTypes(
+             StructInfo<T1>.Index,
+             StructInfo<T2>.Index,
+             StructInfo<T3>.Index,
+             StructInfo<T4>.Index,
+             StructInfo<T5>.Index,
+             StructInfo<T6>.Index,
+             StructInfo<T7>.Index);
+     }
     
-    internal static ComponentTypes Get<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>()
-        where T1 : struct, IComponent
-        where T2 : struct, IComponent
-        where T3 : struct, IComponent
-        where T4 : struct, IComponent
-        where T5 : struct, IComponent
-        where T6 : struct, IComponent
-        where T7 : struct, IComponent
-        where T8 : struct, IComponent
-        where T9 : struct, IComponent
-        where T10: struct, IComponent
-    {
-        return new ComponentTypes(
-            StructInfo<T1>.Index,
-            StructInfo<T2>.Index,
-            StructInfo<T3>.Index,
-            StructInfo<T4>.Index,
-            StructInfo<T5>.Index,
-            StructInfo<T6>.Index,
-            StructInfo<T7>.Index,
-            StructInfo<T8>.Index,
-            StructInfo<T9>.Index,
-            StructInfo<T10>.Index);
-    }*/
+    /*
+     internal static ComponentTypes Get<T1, T2, T3, T4, T5, T6, T7, T8>()
+         where T1 : struct, IComponent
+         where T2 : struct, IComponent
+         where T3 : struct, IComponent
+         where T4 : struct, IComponent
+         where T5 : struct, IComponent
+         where T6 : struct, IComponent
+         where T7 : struct, IComponent
+         where T8 : struct, IComponent
+     {
+         return new ComponentTypes(
+             StructInfo<T1>.Index,
+             StructInfo<T2>.Index,
+             StructInfo<T3>.Index,
+             StructInfo<T4>.Index,
+             StructInfo<T5>.Index,
+             StructInfo<T6>.Index,
+             StructInfo<T7>.Index,
+             StructInfo<T8>.Index);
+     }
+
+     internal static ComponentTypes Get<T1, T2, T3, T4, T5, T6, T7, T8, T9>()
+         where T1 : struct, IComponent
+         where T2 : struct, IComponent
+         where T3 : struct, IComponent
+         where T4 : struct, IComponent
+         where T5 : struct, IComponent
+         where T6 : struct, IComponent
+         where T7 : struct, IComponent
+         where T8 : struct, IComponent
+         where T9 : struct, IComponent
+     {
+         return new ComponentTypes(
+             StructInfo<T1>.Index,
+             StructInfo<T2>.Index,
+             StructInfo<T3>.Index,
+             StructInfo<T4>.Index,
+             StructInfo<T5>.Index,
+             StructInfo<T6>.Index,
+             StructInfo<T7>.Index,
+             StructInfo<T8>.Index,
+             StructInfo<T9>.Index);
+     }
+
+     internal static ComponentTypes Get<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>()
+         where T1 : struct, IComponent
+         where T2 : struct, IComponent
+         where T3 : struct, IComponent
+         where T4 : struct, IComponent
+         where T5 : struct, IComponent
+         where T6 : struct, IComponent
+         where T7 : struct, IComponent
+         where T8 : struct, IComponent
+         where T9 : struct, IComponent
+         where T10: struct, IComponent
+     {
+         return new ComponentTypes(
+             StructInfo<T1>.Index,
+             StructInfo<T2>.Index,
+             StructInfo<T3>.Index,
+             StructInfo<T4>.Index,
+             StructInfo<T5>.Index,
+             StructInfo<T6>.Index,
+             StructInfo<T7>.Index,
+             StructInfo<T8>.Index,
+             StructInfo<T9>.Index,
+             StructInfo<T10>.Index);
+     }*/
     #endregion
     
 #region internal methods
diff --git a/src/ECS/Query/Arg.6/IEach.cs b/src/ECS/Query/Arg.6/IEach.cs
new file mode 100644
index 000000000..b5b64c720
--- /dev/null
+++ b/src/ECS/Query/Arg.6/IEach.cs
@@ -0,0 +1,16 @@
+// Copyright (c) Ullrich Praetz - https://github.com/friflo. All rights reserved.
+// See LICENSE file in the project root for full license information.
+
+
+// ReSharper disable once CheckNamespace
+namespace Friflo.Engine.ECS;
+
+public interface IEach<T1, T2, T3, T4, T5, T6>
+{
+    void Execute(ref T1 c1, ref T2 c2, ref T3 c3, ref T4 c4, ref T5 c5, ref T6 c6);
+}
+
+public interface IEachEntity<T1, T2, T3, T4, T5, T6>
+{
+    void Execute(ref T1 c1, ref T2 c2, ref T3 c3, ref T4 c4, ref T5 c5, ref T6 c6, int id);
+}
\ No newline at end of file
diff --git a/src/ECS/Query/Arg.6/Query.Chunks.cs b/src/ECS/Query/Arg.6/Query.Chunks.cs
new file mode 100644
index 000000000..9eb63bbb1
--- /dev/null
+++ b/src/ECS/Query/Arg.6/Query.Chunks.cs
@@ -0,0 +1,209 @@
+// Copyright (c) Ullrich Praetz - https://github.com/friflo. All rights reserved.
+// See LICENSE file in the project root for full license information.
+
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
+
+// ReSharper disable InconsistentNaming
+// ReSharper disable once CheckNamespace
+namespace Friflo.Engine.ECS;
+
+/// <summary>
+/// Contains the components returned by a component query.
+/// See <a href="https://friflo.gitbook.io/friflo.engine.ecs/documentation/query-optimization#enumerate-query-chunks">Example.</a>
+/// </summary>
+public readonly struct Chunks<T1, T2, T3, T4, T5, T6>
+    where T1 : struct
+    where T2 : struct
+    where T3 : struct
+    where T4 : struct
+    where T5 : struct
+    where T6 : struct
+{
+    public              int             Length => Chunk1.Length;
+    public readonly     Chunk<T1>       Chunk1;     //  16
+    public readonly     Chunk<T2>       Chunk2;     //  16
+    public readonly     Chunk<T3>       Chunk3;     //  16
+    public readonly     Chunk<T4>       Chunk4;     //  16
+    public readonly     Chunk<T5>       Chunk5;     //  16
+    public readonly     Chunk<T6>       Chunk6;     //  16
+    public readonly     ChunkEntities   Entities;   //  32
+
+    public override     string          ToString() => Entities.GetChunksString();
+
+    internal Chunks(Chunk<T1> chunk1, Chunk<T2> chunk2, Chunk<T3> chunk3, Chunk<T4> chunk4, Chunk<T5> chunk5, Chunk<T6> chunk6, in ChunkEntities entities) {
+        Chunk1     = chunk1;
+        Chunk2     = chunk2;
+        Chunk3     = chunk3;
+        Chunk4     = chunk4;
+        Chunk5     = chunk5;
+        Chunk6     = chunk6;
+        Entities   = entities;
+    }
+    
+    internal Chunks(in Chunks<T1, T2, T3, T4, T5, T6> chunks, int start, int length, int taskIndex) {
+        Chunk1      = new Chunk<T1>    (chunks.Chunk1,   start, length);
+        Chunk2      = new Chunk<T2>    (chunks.Chunk2,   start, length);
+        Chunk3      = new Chunk<T3>    (chunks.Chunk3,   start, length);
+        Chunk4      = new Chunk<T4>    (chunks.Chunk4,   start, length);
+        Chunk5      = new Chunk<T5>    (chunks.Chunk5,   start, length);
+        Chunk6      = new Chunk<T6>    (chunks.Chunk6,   start, length);
+        Entities    = new ChunkEntities(chunks.Entities, start, length, taskIndex);
+    }
+    
+    internal Chunks(in ChunkEntities entities, int taskIndex) {
+        Entities   = new ChunkEntities(entities, taskIndex);
+    }
+    
+    public void Deconstruct(out Chunk<T1> chunk1, out Chunk<T2> chunk2, out Chunk<T3> chunk3, out Chunk<T4> chunk4, out Chunk<T5> chunk5,  out Chunk<T6> chunk6, out ChunkEntities entities) {
+        chunk1      = Chunk1;
+        chunk2      = Chunk2;
+        chunk3      = Chunk3;
+        chunk4      = Chunk4;
+        chunk5      = Chunk5;
+        chunk6      = Chunk6;
+        entities    = Entities;
+    }
+}
+
+/// <summary>
+/// Contains the component chunks returned by a component query.
+/// See <a href="https://friflo.gitbook.io/friflo.engine.ecs/documentation/query-optimization#enumerate-query-chunks">Example.</a>
+/// </summary>
+public readonly struct QueryChunks<T1, T2, T3, T4, T5, T6>  : IEnumerable <Chunks<T1, T2, T3, T4, T5, T6>>
+    where T1 : struct
+    where T2 : struct
+    where T3 : struct
+    where T4 : struct
+    where T5 : struct
+    where T6 : struct
+{
+    private readonly    ArchetypeQuery<T1, T2, T3, T4, T5, T6>  query;
+
+    public              int     Count       => query.Count;
+    
+    /// <summary> Obsolete. Renamed to <see cref="Count"/>. </summary>
+    [Obsolete($"Renamed to {nameof(Count)}")] [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+    public              int     EntityCount => query.Count;
+    
+    public  override    string  ToString()  => query.GetQueryChunksString();
+
+    internal QueryChunks(ArchetypeQuery<T1, T2, T3, T4, T5, T6> query) {
+        this.query = query;
+    }
+    
+    // --- IEnumerable<>
+    [ExcludeFromCodeCoverage]
+    IEnumerator<Chunks<T1, T2, T3, T4, T5, T6>>
+    IEnumerable<Chunks<T1, T2, T3, T4, T5, T6>>.GetEnumerator() => new ChunkEnumerator<T1, T2, T3, T4, T5, T6> (query);
+    
+    // --- IEnumerable
+    [ExcludeFromCodeCoverage]
+    IEnumerator     IEnumerable.GetEnumerator() => new ChunkEnumerator<T1, T2, T3, T4, T5, T6> (query);
+    
+    public ChunkEnumerator<T1, T2, T3, T4, T5, T6> GetEnumerator() => new (query);
+}
+
+public struct ChunkEnumerator<T1, T2, T3, T4, T5, T6> : IEnumerator<Chunks<T1, T2, T3, T4, T5, T6>>
+    where T1 : struct
+    where T2 : struct
+    where T3 : struct
+    where T4 : struct
+    where T5 : struct
+    where T6 : struct
+{
+    private readonly    int                     structIndex1;   //  4
+    private readonly    int                     structIndex2;   //  4
+    private readonly    int                     structIndex3;   //  4
+    private readonly    int                     structIndex4;   //  4
+    private readonly    int                     structIndex5;   //  4
+    private readonly    int                     structIndex6;   //  4
+    //
+    private readonly    Archetypes              archetypes;     // 16
+    //
+    private             int                     archetypePos;   //  4
+    private             Chunks<T1,T2,T3,T4,T5,T6>  chunks;         // 104
+    
+    
+    internal  ChunkEnumerator(ArchetypeQuery<T1, T2, T3, T4, T5, T6> query)
+    {
+        structIndex1    = query.signatureIndexes.T1;
+        structIndex2    = query.signatureIndexes.T2;
+        structIndex3    = query.signatureIndexes.T3;
+        structIndex4    = query.signatureIndexes.T4;
+        structIndex5    = query.signatureIndexes.T5;
+        structIndex6    = query.signatureIndexes.T6;
+        archetypes      = query.GetArchetypes();
+        archetypePos    = -1;
+    }
+    
+    /// <summary>return Current by reference to avoid struct copy and enable mutation in library</summary>
+    public readonly Chunks<T1, T2, T3, T4, T5, T6> Current   => chunks;
+    
+    // --- IEnumerator
+    [ExcludeFromCodeCoverage]
+    public void Reset() {
+        archetypePos    = -1;
+        chunks          = default;
+    }
+
+    [ExcludeFromCodeCoverage]
+    object IEnumerator.Current  => chunks;
+    
+    // --- IEnumerator
+    public bool MoveNext()
+    {
+        Archetype archetype;
+        int count;
+        int start = 0;
+        var types = archetypes;
+        var pos   = archetypePos;
+        if (types.chunkPositions != null) {
+            goto SingleEntity;
+        }
+        do {
+            if (pos >= types.last) {  // last = length - 1
+                archetypePos = pos;
+                return false;
+            }
+            archetype   = types.array[++pos];
+            count       = archetype.entityCount;
+        }
+        while (count == 0); // skip archetypes without entities
+    SetChunks:
+        archetypePos    = pos;
+        var heapMap     = archetype.heapMap;
+        var chunks1     = (StructHeap<T1>)heapMap[structIndex1];
+        var chunks2     = (StructHeap<T2>)heapMap[structIndex2];
+        var chunks3     = (StructHeap<T3>)heapMap[structIndex3];
+        var chunks4     = (StructHeap<T4>)heapMap[structIndex4];
+        var chunks5     = (StructHeap<T5>)heapMap[structIndex5];
+        var chunks6     = (StructHeap<T6>)heapMap[structIndex6];
+
+        var chunk1      = new Chunk<T1>(chunks1.components, count, start);
+        var chunk2      = new Chunk<T2>(chunks2.components, count, start);
+        var chunk3      = new Chunk<T3>(chunks3.components, count, start);
+        var chunk4      = new Chunk<T4>(chunks4.components, count, start);
+        var chunk5      = new Chunk<T5>(chunks5.components, count, start);
+        var chunk6      = new Chunk<T6>(chunks6.components, count, start);
+        var entities    = new ChunkEntities(archetype,      count, start);
+        chunks          = new Chunks<T1, T2, T3, T4, T5, T6>(chunk1, chunk2, chunk3, chunk4, chunk5, chunk6, entities);
+        return true;
+    SingleEntity:
+        if (pos >= types.last) {
+            return false;
+        }
+        pos++;
+        start       = types.chunkPositions[pos];
+        archetype   = types.array         [pos];
+        count       = 1;
+        goto SetChunks;
+    }
+    
+    // --- IDisposable
+    public void Dispose() { }
+}
diff --git a/src/ECS/Query/Arg.6/Query.cs b/src/ECS/Query/Arg.6/Query.cs
new file mode 100644
index 000000000..344b42674
--- /dev/null
+++ b/src/ECS/Query/Arg.6/Query.cs
@@ -0,0 +1,99 @@
+// Copyright (c) Ullrich Praetz - https://github.com/friflo. All rights reserved.
+// See LICENSE file in the project root for full license information.
+
+using System;
+
+// ReSharper disable once CheckNamespace
+namespace Friflo.Engine.ECS;
+
+/// <summary>
+/// Provide the state of an <paramref name="entity"/> within <see cref="ArchetypeQuery{T1,T2,T3,T4,T5,T6}.ForEachEntity"/>.
+/// </summary>
+public delegate void ForEachEntity<T1, T2, T3, T4, T5, T6>(ref T1 component1, ref T2 component2, ref T3 component3, ref T4 component4, ref T5 component5, ref T6 component, Entity entity)
+    where T1 : struct
+    where T2 : struct
+    where T3 : struct
+    where T4 : struct
+    where T5 : struct
+    where T6 : struct;
+
+
+/// <summary>
+/// A query instance use to retrieve the given component types.
+/// See <a href="https://friflo.gitbook.io/friflo.engine.ecs/documentation/query">Example.</a>
+/// </summary>
+public sealed class ArchetypeQuery<T1, T2, T3, T4, T5, T6> : ArchetypeQuery
+    where T1 : struct
+    where T2 : struct
+    where T3 : struct
+    where T4 : struct
+    where T5 : struct
+    where T6 : struct
+{
+    /// <inheritdoc          cref="ArchetypeQuery.AllTags"/>
+    public new ArchetypeQuery<T1, T2, T3, T4, T5, T6> AllTags       (in Tags tags) { SetHasAllTags(tags);       return this; }
+    /// <inheritdoc          cref="ArchetypeQuery.AnyTags"/>
+    public new ArchetypeQuery<T1, T2, T3, T4, T5, T6> AnyTags       (in Tags tags) { SetHasAnyTags(tags);       return this; }
+    /// <inheritdoc          cref="ArchetypeQuery.WithDisabled"/>
+    public new ArchetypeQuery<T1, T2, T3, T4, T5, T6> WithDisabled  ()             { SetWithDisabled();         return this; }
+    /// <inheritdoc          cref="ArchetypeQuery.WithoutAllTags"/>
+    public new ArchetypeQuery<T1, T2, T3, T4, T5, T6> WithoutAllTags(in Tags tags) { SetWithoutAllTags(tags);   return this; }
+    /// <inheritdoc          cref="ArchetypeQuery.WithoutAnyTags"/>
+    public new ArchetypeQuery<T1, T2, T3, T4, T5, T6> WithoutAnyTags(in Tags tags) { SetWithoutAnyTags(tags);   return this; }
+    
+    /// <inheritdoc          cref="ArchetypeQuery.AllComponents"/>
+    public new ArchetypeQuery<T1, T2, T3, T4, T5, T6> AllComponents       (in ComponentTypes componentTypes) { SetHasAllComponents(componentTypes);       return this; }
+    /// <inheritdoc          cref="ArchetypeQuery.AnyComponents"/>
+    public new ArchetypeQuery<T1, T2, T3, T4, T5, T6> AnyComponents       (in ComponentTypes componentTypes) { SetHasAnyComponents(componentTypes);       return this; }
+    /// <inheritdoc          cref="ArchetypeQuery.WithoutAllComponents"/>
+    public new ArchetypeQuery<T1, T2, T3, T4, T5, T6> WithoutAllComponents(in ComponentTypes componentTypes) { SetWithoutAllComponents(componentTypes);   return this; }
+    /// <inheritdoc          cref="ArchetypeQuery.WithoutAnyComponents"/>
+    public new ArchetypeQuery<T1, T2, T3, T4, T5, T6> WithoutAnyComponents(in ComponentTypes componentTypes) { SetWithoutAnyComponents(componentTypes);   return this; }
+    
+    /// <inheritdoc cref="QueryFilter.HasValue{TComponent,TValue}"/>
+    public new ArchetypeQuery<T1, T2, T3, T4, T5, T6> HasValue    <TComponent,TValue>(TValue value)           where TComponent : struct, IIndexedComponent<TValue>
+    { base.HasValue    <TComponent, TValue>(value);    return this; }
+    
+    /// <inheritdoc cref="QueryFilter.ValueInRange{TComponent,TValue}"/>
+    public new ArchetypeQuery<T1, T2, T3, T4, T5, T6> ValueInRange<TComponent,TValue>(TValue min, TValue max) where TComponent : struct, IIndexedComponent<TValue> where TValue : IComparable<TValue>
+    { base.ValueInRange<TComponent, TValue>(min, max); return this; }
+    
+    /// <inheritdoc          cref="ArchetypeQuery.FreezeFilter"/>
+    public new ArchetypeQuery<T1, T2, T3, T4, T5, T6> FreezeFilter() { SetFreezeFilter();   return this; }
+    
+    internal ArchetypeQuery(EntityStoreBase store, in Signature<T1, T2, T3, T4, T5, T6> signature, QueryFilter filter)
+        : base(store, signature.signatureIndexes, filter, null) {
+    }
+    
+    /// <summary>
+    /// Return the <see cref="Chunk{T}"/>'s storing the components and entities of an <see cref="ArchetypeQuery{T1,T2,T3,T4,T5,T6}"/>.<br/>
+    /// See <a href="https://friflo.gitbook.io/friflo.engine.ecs/documentation/query-optimization#enumerate-query-chunks">Example.</a>
+    /// </summary>
+    public      QueryChunks    <T1, T2, T3, T4, T5, T6>  Chunks         => new (this);
+    
+    /// <summary>
+    /// Returns a <see cref="QueryJob"/> that enables <see cref="JobExecution.Parallel"/> query execution.  
+    /// </summary>
+    public QueryJob<T1, T2, T3, T4, T5, T6> ForEach(Action<Chunk<T1>, Chunk<T2>, Chunk<T3>, Chunk<T4>, Chunk<T5>, Chunk<T6>, ChunkEntities> action)  => new (this, action);
+    
+    /// <summary>
+    /// Executes the given <paramref name="lambda"/> for each entity in the query result.
+    /// </summary>
+    public void ForEachEntity(ForEachEntity<T1, T2, T3, T4, T5, T6> lambda)
+    {
+        var store = Store;
+        foreach (var (chunk1, chunk2, chunk3, chunk4, chunk5, chunk6, entities) in Chunks)
+        {
+            var span1   = chunk1.Span;
+            var span2   = chunk2.Span;
+            var span3   = chunk3.Span;
+            var span4   = chunk4.Span;
+            var span5   = chunk5.Span;
+            var span6   = chunk6.Span;
+            var ids     = entities.Ids;
+            for (int n = 0; n < chunk1.Length; n++) {
+                lambda(ref span1[n], ref span2[n], ref span3[n], ref span4[n], ref span5[n], ref span6[n], new Entity(store, ids[n]));    
+            }
+        }
+    }
+}
diff --git a/src/ECS/Query/Arg.6/QueryJob.cs b/src/ECS/Query/Arg.6/QueryJob.cs
new file mode 100644
index 000000000..812a75759
--- /dev/null
+++ b/src/ECS/Query/Arg.6/QueryJob.cs
@@ -0,0 +1,120 @@
+// Copyright (c) Ullrich Praetz - https://github.com/friflo. All rights reserved.
+// See LICENSE file in the project root for full license information.
+
+using System;
+using static System.Diagnostics.DebuggerBrowsableState;
+using Browse = System.Diagnostics.DebuggerBrowsableAttribute;
+
+// ReSharper disable StaticMemberInGenericType
+// ReSharper disable CoVariantArrayConversion
+// ReSharper disable once CheckNamespace
+namespace Friflo.Engine.ECS;
+
+/// <summary>
+/// Enables <see cref="JobExecution.Parallel"/> query execution returning the specified components.
+/// See <a href="https://friflo.gitbook.io/friflo.engine.ecs/documentation/query-optimization#parallel-query-job">Example.</a>
+/// </summary>
+public sealed class QueryJob<T1, T2, T3, T4, T5, T6> : QueryJob
+    where T1 : struct
+    where T2 : struct
+    where T3 : struct
+    where T4 : struct
+    where T5 : struct
+    where T6 : struct
+{
+    internal            QueryChunks<T1, T2, T3, T4, T5, T6> Chunks      => new (query);     // only for debugger
+    internal            QueryEntities                       Entities    => query.Entities;  // only for debugger
+    public  override    string                              ToString()  => query.GetQueryJobString();
+
+    [Browse(Never)]
+    private readonly    ArchetypeQuery<T1, T2, T3, T4, T5, T6>                                                     query;      //  8
+    private readonly    Action<Chunk<T1>, Chunk<T2>, Chunk<T3>, Chunk<T4>, Chunk<T5>, Chunk<T6>, ChunkEntities>    action;     //  8
+    [Browse(Never)]
+    private             QueryJobTask[]                                                                             jobTasks;   //  8
+
+
+    private class QueryJobTask : JobTask {
+        internal    Action<Chunk<T1>, Chunk<T2>, Chunk<T3>, Chunk<T4>, Chunk<T5>, Chunk<T6>, ChunkEntities>    action;
+        internal    Chunks<T1, T2, T3, T4, T5, T6>                                                             chunks;
+        
+        internal  override void ExecuteTask()  => action(chunks.Chunk1, chunks.Chunk2, chunks.Chunk3, chunks.Chunk4, chunks.Chunk5, chunks.Chunk6, chunks.Entities);
+    }
+    
+    internal QueryJob(
+        ArchetypeQuery<T1, T2, T3, T4, T5, T6>                                                     query,
+        Action<Chunk<T1>, Chunk<T2>, Chunk<T3>, Chunk<T4>, Chunk<T5>, Chunk<T6>, ChunkEntities>    action)
+    {
+        this.query  = query;
+        this.action = action;
+        jobRunner   = query.Store.JobRunner;
+    }
+    
+    public override void Run()
+    {
+        foreach (Chunks<T1, T2, T3, T4, T5, T6> chunk in query.Chunks) {
+            action(chunk.Chunk1, chunk.Chunk2, chunk.Chunk3, chunk.Chunk4, chunk.Chunk5, chunk.Chunk6, chunk.Entities);
+        }
+    }
+    
+    /// <summary>Execute the query.
+    /// See <a href="https://friflo.gitbook.io/friflo.engine.ecs/documentation/query-optimization#parallel-query-job">Example.</a>.<br/>
+    /// All chunks having at least <see cref="QueryJob.MinParallelChunkLength"/> * <see cref="ParallelJobRunner.ThreadCount"/>
+    /// components are executed <see cref="JobExecution.Parallel"/>. 
+    /// </summary>
+    public override void RunParallel()
+    {
+        if (jobRunner == null) throw JobRunnerIsNullException();
+        var taskCount   = jobRunner.workerCount + 1;
+        
+        foreach (Chunks<T1, T2, T3, T4, T5, T6> chunks in query.Chunks)
+        {
+            var chunkLength = chunks.Length;
+            if (ExecuteSequential(taskCount, chunkLength)) {
+                action(chunks.Chunk1, chunks.Chunk2, chunks.Chunk3, chunks.Chunk4, chunks.Chunk5, chunks.Chunk6, chunks.Entities);
+                continue;
+            }
+            var tasks = jobTasks;
+            if (tasks == null || tasks.Length < taskCount) {
+                tasks = jobTasks = new QueryJobTask[taskCount];
+                for (int n = 0; n < taskCount; n++) {
+                    tasks[n] = new QueryJobTask { action = action };
+                }
+            }
+            var sectionSize = GetSectionSize(chunkLength, taskCount, Multiple);
+            var start       = 0;
+            for (int taskIndex = 0; taskIndex < taskCount; taskIndex++)
+            {
+                var length = GetSectionLength (chunkLength, start, sectionSize);
+                if (length > 0) {
+                    tasks[taskIndex].chunks = new Chunks<T1, T2, T3, T4, T5, T6>(chunks, start, length, taskIndex);
+                    start += sectionSize;
+                    continue;
+                }
+                for (; taskIndex < taskCount; taskIndex++) {
+                    tasks[taskIndex].chunks = new Chunks<T1, T2, T3, T4, T5, T6>(chunks.Entities, taskIndex);
+                }
+                break;
+            }
+            jobRunner.ExecuteJob(this, tasks);
+        }
+    }
+    
+    public  override        int ParallelComponentMultiple   => Multiple;
+    private static readonly int Multiple                    = GetMultiple();
+    
+    private static int GetMultiple()
+    {
+        int lcm1 = StructPadding<T1>.ComponentMultiple;
+        int lcm2 = StructPadding<T2>.ComponentMultiple;
+        int lcm3 = StructPadding<T3>.ComponentMultiple;
+        int lcm4 = StructPadding<T4>.ComponentMultiple;
+        int lcm5 = StructPadding<T5>.ComponentMultiple;
+        int lcm6 = StructPadding<T6>.ComponentMultiple;
+        
+        int lcm12   =   LeastComponentMultiple(lcm1,    lcm2);
+        int lcm34   =   LeastComponentMultiple(lcm3,    lcm4);
+        int lcm1234 =   LeastComponentMultiple(lcm12,   lcm34);
+        int lcm12345 =  LeastComponentMultiple(lcm1234, lcm5);
+        return          LeastComponentMultiple(lcm12345, lcm6);
+    }
+}
diff --git a/src/ECS/Query/Arg.7/IEach.cs b/src/ECS/Query/Arg.7/IEach.cs
new file mode 100644
index 000000000..7e4c53cfb
--- /dev/null
+++ b/src/ECS/Query/Arg.7/IEach.cs
@@ -0,0 +1,16 @@
+// Copyright (c) Ullrich Praetz - https://github.com/friflo. All rights reserved.
+// See LICENSE file in the project root for full license information.
+
+
+// ReSharper disable once CheckNamespace
+namespace Friflo.Engine.ECS;
+
+public interface IEach<T1, T2, T3, T4, T5, T6, T7>
+{
+    void Execute(ref T1 c1, ref T2 c2, ref T3 c3, ref T4 c4, ref T5 c5, ref T6 c6, ref T7 c7);
+}
+
+public interface IEachEntity<T1, T2, T3, T4, T5, T6, T7>
+{
+    void Execute(ref T1 c1, ref T2 c2, ref T3 c3, ref T4 c4, ref T5 c5, ref T6 c6, ref T7 c7, int id);
+}
\ No newline at end of file
diff --git a/src/ECS/Query/Arg.7/Query.Chunks.cs b/src/ECS/Query/Arg.7/Query.Chunks.cs
new file mode 100644
index 000000000..0c0a0195c
--- /dev/null
+++ b/src/ECS/Query/Arg.7/Query.Chunks.cs
@@ -0,0 +1,222 @@
+// Copyright (c) Ullrich Praetz - https://github.com/friflo. All rights reserved.
+// See LICENSE file in the project root for full license information.
+
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
+
+// ReSharper disable InconsistentNaming
+// ReSharper disable once CheckNamespace
+namespace Friflo.Engine.ECS;
+
+/// <summary>
+/// Contains the components returned by a component query.
+/// See <a href="https://friflo.gitbook.io/friflo.engine.ecs/documentation/query-optimization#enumerate-query-chunks">Example.</a>
+/// </summary>
+public readonly struct Chunks<T1, T2, T3, T4, T5, T6, T7>
+    where T1 : struct
+    where T2 : struct
+    where T3 : struct
+    where T4 : struct
+    where T5 : struct
+    where T6 : struct
+    where T7 : struct
+{
+    public              int             Length => Chunk1.Length;
+    public readonly     Chunk<T1>       Chunk1;     //  16
+    public readonly     Chunk<T2>       Chunk2;     //  16
+    public readonly     Chunk<T3>       Chunk3;     //  16
+    public readonly     Chunk<T4>       Chunk4;     //  16
+    public readonly     Chunk<T5>       Chunk5;     //  16
+    public readonly     Chunk<T6>       Chunk6;     //  16
+    public readonly     Chunk<T7>       Chunk7;     //  16
+    public readonly     ChunkEntities   Entities;   //  32
+
+    public override     string          ToString() => Entities.GetChunksString();
+
+    internal Chunks(Chunk<T1> chunk1, Chunk<T2> chunk2, Chunk<T3> chunk3, Chunk<T4> chunk4, Chunk<T5> chunk5, Chunk<T6> chunk6, Chunk<T7> chunk7, in ChunkEntities entities) {
+        Chunk1     = chunk1;
+        Chunk2     = chunk2;
+        Chunk3     = chunk3;
+        Chunk4     = chunk4;
+        Chunk5     = chunk5;
+        Chunk6     = chunk6;
+        Chunk7     = chunk7;
+        Entities   = entities;
+    }
+    
+    internal Chunks(in Chunks<T1, T2, T3, T4, T5, T6, T7> chunks, int start, int length, int taskIndex) {
+        Chunk1      = new Chunk<T1>    (chunks.Chunk1,   start, length);
+        Chunk2      = new Chunk<T2>    (chunks.Chunk2,   start, length);
+        Chunk3      = new Chunk<T3>    (chunks.Chunk3,   start, length);
+        Chunk4      = new Chunk<T4>    (chunks.Chunk4,   start, length);
+        Chunk5      = new Chunk<T5>    (chunks.Chunk5,   start, length);
+        Chunk6      = new Chunk<T6>    (chunks.Chunk6,   start, length);
+        Chunk7      = new Chunk<T7>    (chunks.Chunk7,   start, length);
+        Entities    = new ChunkEntities(chunks.Entities, start, length, taskIndex);
+    }
+    
+    internal Chunks(in ChunkEntities entities, int taskIndex) {
+        Entities   = new ChunkEntities(entities, taskIndex);
+    }
+    
+    public void Deconstruct(out Chunk<T1> chunk1, out Chunk<T2> chunk2, out Chunk<T3> chunk3, out Chunk<T4> chunk4, out Chunk<T5> chunk5, out Chunk<T6> chunk6, out Chunk<T7> chunk7, out ChunkEntities entities) {
+        chunk1      = Chunk1;
+        chunk2      = Chunk2;
+        chunk3      = Chunk3;
+        chunk4      = Chunk4;
+        chunk5      = Chunk5;
+        chunk6      = Chunk6;
+        chunk7      = Chunk7;
+        entities    = Entities;
+    }
+}
+
+/// <summary>
+/// Contains the component chunks returned by a component query.
+/// See <a href="https://friflo.gitbook.io/friflo.engine.ecs/documentation/query-optimization#enumerate-query-chunks">Example.</a>
+/// </summary>
+public readonly struct QueryChunks<T1, T2, T3, T4, T5, T6, T7>  : IEnumerable <Chunks<T1, T2, T3, T4, T5, T6, T7>>
+    where T1 : struct
+    where T2 : struct
+    where T3 : struct
+    where T4 : struct
+    where T5 : struct
+    where T6 : struct
+    where T7 : struct
+{
+    private readonly    ArchetypeQuery<T1, T2, T3, T4, T5, T6, T7>  query;
+
+    public              int     Count       => query.Count;
+    
+    /// <summary> Obsolete. Renamed to <see cref="Count"/>. </summary>
+    [Obsolete($"Renamed to {nameof(Count)}")] [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+    public              int     EntityCount => query.Count;
+    
+    public  override    string  ToString()  => query.GetQueryChunksString();
+
+    internal QueryChunks(ArchetypeQuery<T1, T2, T3, T4, T5, T6, T7> query) {
+        this.query = query;
+    }
+    
+    // --- IEnumerable<>
+    [ExcludeFromCodeCoverage]
+    IEnumerator<Chunks<T1, T2, T3, T4, T5, T6, T7>>
+    IEnumerable<Chunks<T1, T2, T3, T4, T5, T6, T7>>.GetEnumerator() => new ChunkEnumerator<T1, T2, T3, T4, T5, T6, T7> (query);
+    
+    // --- IEnumerable
+    [ExcludeFromCodeCoverage]
+    IEnumerator     IEnumerable.GetEnumerator() => new ChunkEnumerator<T1, T2, T3, T4, T5, T6, T7> (query);
+    
+    public ChunkEnumerator<T1, T2, T3, T4, T5, T6, T7> GetEnumerator() => new (query);
+}
+
+
+public struct ChunkEnumerator<T1, T2, T3, T4, T5, T6, T7> : IEnumerator<Chunks<T1, T2, T3, T4, T5, T6, T7>>
+    where T1 : struct
+    where T2 : struct
+    where T3 : struct
+    where T4 : struct
+    where T5 : struct
+    where T6 : struct
+    where T7 : struct
+{
+    private readonly    int                     structIndex1;   //  4
+    private readonly    int                     structIndex2;   //  4
+    private readonly    int                     structIndex3;   //  4
+    private readonly    int                     structIndex4;   //  4
+    private readonly    int                     structIndex5;   //  4
+    private readonly    int                     structIndex6;   //  4
+    private readonly    int                     structIndex7;   //  4
+    //
+    private readonly    Archetypes              archetypes;     // 16
+    //
+    private             int                     archetypePos;   //  4
+    private             Chunks<T1,T2,T3,T4,T5,T6,T7>  chunks;         // 104
+    
+    
+    internal  ChunkEnumerator(ArchetypeQuery<T1, T2, T3, T4, T5, T6, T7> query)
+    {
+        structIndex1    = query.signatureIndexes.T1;
+        structIndex2    = query.signatureIndexes.T2;
+        structIndex3    = query.signatureIndexes.T3;
+        structIndex4    = query.signatureIndexes.T4;
+        structIndex5    = query.signatureIndexes.T5;
+        structIndex6    = query.signatureIndexes.T6;
+        structIndex7    = query.signatureIndexes.T7;
+        
+        archetypes      = query.GetArchetypes();
+        archetypePos    = -1;
+    }
+    
+    /// <summary>return Current by reference to avoid struct copy and enable mutation in library</summary>
+    public readonly Chunks<T1, T2, T3, T4, T5, T6, T7> Current   => chunks;
+    
+    // --- IEnumerator
+    [ExcludeFromCodeCoverage]
+    public void Reset() {
+        archetypePos    = -1;
+        chunks          = default;
+    }
+
+    [ExcludeFromCodeCoverage]
+    object IEnumerator.Current  => chunks;
+    
+    // --- IEnumerator
+    public bool MoveNext()
+    {
+        Archetype archetype;
+        int count;
+        int start = 0;
+        var types = archetypes;
+        var pos   = archetypePos;
+        if (types.chunkPositions != null) {
+            goto SingleEntity;
+        }
+        do {
+            if (pos >= types.last) {  // last = length - 1
+                archetypePos = pos;
+                return false;
+            }
+            archetype   = types.array[++pos];
+            count       = archetype.entityCount;
+        }
+        while (count == 0); // skip archetypes without entities
+    SetChunks:
+        archetypePos    = pos;
+        var heapMap     = archetype.heapMap;
+        var chunks1     = (StructHeap<T1>)heapMap[structIndex1];
+        var chunks2     = (StructHeap<T2>)heapMap[structIndex2];
+        var chunks3     = (StructHeap<T3>)heapMap[structIndex3];
+        var chunks4     = (StructHeap<T4>)heapMap[structIndex4];
+        var chunks5     = (StructHeap<T5>)heapMap[structIndex5];
+        var chunks6     = (StructHeap<T6>)heapMap[structIndex6];
+        var chunks7     = (StructHeap<T7>)heapMap[structIndex7];
+
+        var chunk1      = new Chunk<T1>(chunks1.components, count, start);
+        var chunk2      = new Chunk<T2>(chunks2.components, count, start);
+        var chunk3      = new Chunk<T3>(chunks3.components, count, start);
+        var chunk4      = new Chunk<T4>(chunks4.components, count, start);
+        var chunk5      = new Chunk<T5>(chunks5.components, count, start);
+        var chunk6      = new Chunk<T6>(chunks6.components, count, start);
+        var chunk7      = new Chunk<T7>(chunks7.components, count, start);
+        var entities    = new ChunkEntities(archetype,      count, start);
+        chunks          = new Chunks<T1, T2, T3, T4, T5, T6, T7>(chunk1, chunk2, chunk3, chunk4, chunk5, chunk6, chunk7, entities);
+        return true;
+    SingleEntity:
+        if (pos >= types.last) {
+            return false;
+        }
+        pos++;
+        start       = types.chunkPositions[pos];
+        archetype   = types.array         [pos];
+        count       = 1;
+        goto SetChunks;
+    }
+    
+    // --- IDisposable
+    public void Dispose() { }
+}
diff --git a/src/ECS/Query/Arg.7/Query.cs b/src/ECS/Query/Arg.7/Query.cs
new file mode 100644
index 000000000..c22ee70bc
--- /dev/null
+++ b/src/ECS/Query/Arg.7/Query.cs
@@ -0,0 +1,103 @@
+// Copyright (c) Ullrich Praetz - https://github.com/friflo. All rights reserved.
+// See LICENSE file in the project root for full license information.
+
+using System;
+
+// ReSharper disable once CheckNamespace
+namespace Friflo.Engine.ECS;
+
+/// <summary>
+/// Provide the state of an <paramref name="entity"/> within <see cref="ArchetypeQuery{T1,T2,T3,T4,T5,T6}.ForEachEntity"/>.
+/// </summary>
+public delegate void ForEachEntity<T1, T2, T3, T4, T5, T6, T7>(ref T1 component1, ref T2 component2, ref T3 component3, ref T4 component4, ref T5 component5, ref T6 component6, ref T7 component7, Entity entity)
+    where T1 : struct
+    where T2 : struct
+    where T3 : struct
+    where T4 : struct
+    where T5 : struct
+    where T6 : struct
+    where T7 : struct;
+
+
+/// <summary>
+/// A query instance use to retrieve the given component types.
+/// See <a href="https://friflo.gitbook.io/friflo.engine.ecs/documentation/query">Example.</a>
+/// </summary>
+public sealed class ArchetypeQuery<T1, T2, T3, T4, T5, T6, T7> : ArchetypeQuery
+    where T1 : struct
+    where T2 : struct
+    where T3 : struct
+    where T4 : struct
+    where T5 : struct
+    where T6 : struct
+    where T7 : struct
+{
+    /// <inheritdoc          cref="ArchetypeQuery.AllTags"/>
+    public new ArchetypeQuery<T1, T2, T3, T4, T5, T6, T7> AllTags       (in Tags tags) { SetHasAllTags(tags);       return this; }
+    /// <inheritdoc          cref="ArchetypeQuery.AnyTags"/>
+    public new ArchetypeQuery<T1, T2, T3, T4, T5, T6, T7> AnyTags       (in Tags tags) { SetHasAnyTags(tags);       return this; }
+    /// <inheritdoc          cref="ArchetypeQuery.WithDisabled"/>
+    public new ArchetypeQuery<T1, T2, T3, T4, T5, T6, T7> WithDisabled  ()             { SetWithDisabled();         return this; }
+    /// <inheritdoc          cref="ArchetypeQuery.WithoutAllTags"/>
+    public new ArchetypeQuery<T1, T2, T3, T4, T5, T6, T7> WithoutAllTags(in Tags tags) { SetWithoutAllTags(tags);   return this; }
+    /// <inheritdoc          cref="ArchetypeQuery.WithoutAnyTags"/>
+    public new ArchetypeQuery<T1, T2, T3, T4, T5, T6, T7> WithoutAnyTags(in Tags tags) { SetWithoutAnyTags(tags);   return this; }
+    
+    /// <inheritdoc          cref="ArchetypeQuery.AllComponents"/>
+    public new ArchetypeQuery<T1, T2, T3, T4, T5, T6, T7> AllComponents       (in ComponentTypes componentTypes) { SetHasAllComponents(componentTypes);       return this; }
+    /// <inheritdoc          cref="ArchetypeQuery.AnyComponents"/>
+    public new ArchetypeQuery<T1, T2, T3, T4, T5, T6, T7> AnyComponents       (in ComponentTypes componentTypes) { SetHasAnyComponents(componentTypes);       return this; }
+    /// <inheritdoc          cref="ArchetypeQuery.WithoutAllComponents"/>
+    public new ArchetypeQuery<T1, T2, T3, T4, T5, T6, T7> WithoutAllComponents(in ComponentTypes componentTypes) { SetWithoutAllComponents(componentTypes);   return this; }
+    /// <inheritdoc          cref="ArchetypeQuery.WithoutAnyComponents"/>
+    public new ArchetypeQuery<T1, T2, T3, T4, T5, T6, T7> WithoutAnyComponents(in ComponentTypes componentTypes) { SetWithoutAnyComponents(componentTypes);   return this; }
+    
+    /// <inheritdoc cref="QueryFilter.HasValue{TComponent,TValue}"/>
+    public new ArchetypeQuery<T1, T2, T3, T4, T5, T6, T7> HasValue    <TComponent,TValue>(TValue value)           where TComponent : struct, IIndexedComponent<TValue>
+    { base.HasValue    <TComponent, TValue>(value);    return this; }
+    
+    /// <inheritdoc cref="QueryFilter.ValueInRange{TComponent,TValue}"/>
+    public new ArchetypeQuery<T1, T2, T3, T4, T5, T6, T7> ValueInRange<TComponent,TValue>(TValue min, TValue max) where TComponent : struct, IIndexedComponent<TValue> where TValue : IComparable<TValue>
+    { base.ValueInRange<TComponent, TValue>(min, max); return this; }
+    
+    /// <inheritdoc          cref="ArchetypeQuery.FreezeFilter"/>
+    public new ArchetypeQuery<T1, T2, T3, T4, T5, T6, T7> FreezeFilter() { SetFreezeFilter();   return this; }
+    
+    internal ArchetypeQuery(EntityStoreBase store, in Signature<T1, T2, T3, T4, T5, T6, T7> signature, QueryFilter filter)
+        : base(store, signature.signatureIndexes, filter, null) {
+    }
+    
+    /// <summary>
+    /// Return the <see cref="Chunk{T}"/>'s storing the components and entities of an <see cref="ArchetypeQuery{T1,T2,T3,T4,T5,T6,T7}"/>.<br/>
+    /// See <a href="https://friflo.gitbook.io/friflo.engine.ecs/documentation/query-optimization#enumerate-query-chunks">Example.</a>
+    /// </summary>
+    public      QueryChunks    <T1, T2, T3, T4, T5, T6, T7>  Chunks         => new (this);
+    
+    /// <summary>
+    /// Returns a <see cref="QueryJob"/> that enables <see cref="JobExecution.Parallel"/> query execution.  
+    /// </summary>
+    public QueryJob<T1, T2, T3, T4, T5, T6, T7> ForEach(Action<Chunk<T1>, Chunk<T2>, Chunk<T3>, Chunk<T4>, Chunk<T5>, Chunk<T6>, Chunk<T7>, ChunkEntities> action)  => new (this, action);
+    
+    /// <summary>
+    /// Executes the given <paramref name="lambda"/> for each entity in the query result.
+    /// </summary>
+    public void ForEachEntity(ForEachEntity<T1, T2, T3, T4, T5, T6, T7> lambda)
+    {
+        var store = Store;
+        foreach (var (chunk1, chunk2, chunk3, chunk4, chunk5, chunk6, chunk7, entities) in Chunks)
+        {
+            var span1   = chunk1.Span;
+            var span2   = chunk2.Span;
+            var span3   = chunk3.Span;
+            var span4   = chunk4.Span;
+            var span5   = chunk5.Span;
+            var span6   = chunk6.Span;
+            var span7   = chunk7.Span;
+            
+            var ids     = entities.Ids;
+            for (int n = 0; n < chunk1.Length; n++) {
+                lambda(ref span1[n], ref span2[n], ref span3[n], ref span4[n], ref span5[n], ref span6[n], ref span7[n], new Entity(store, ids[n]));    
+            }
+        }
+    }
+}
diff --git a/src/ECS/Query/Arg.7/QueryJob.cs b/src/ECS/Query/Arg.7/QueryJob.cs
new file mode 100644
index 000000000..f7dbe5366
--- /dev/null
+++ b/src/ECS/Query/Arg.7/QueryJob.cs
@@ -0,0 +1,123 @@
+// Copyright (c) Ullrich Praetz - https://github.com/friflo. All rights reserved.
+// See LICENSE file in the project root for full license information.
+
+using System;
+using static System.Diagnostics.DebuggerBrowsableState;
+using Browse = System.Diagnostics.DebuggerBrowsableAttribute;
+
+// ReSharper disable StaticMemberInGenericType
+// ReSharper disable CoVariantArrayConversion
+// ReSharper disable once CheckNamespace
+namespace Friflo.Engine.ECS;
+
+/// <summary>
+/// Enables <see cref="JobExecution.Parallel"/> query execution returning the specified components.
+/// See <a href="https://friflo.gitbook.io/friflo.engine.ecs/documentation/query-optimization#parallel-query-job">Example.</a>
+/// </summary>
+public sealed class QueryJob<T1, T2, T3, T4, T5, T6, T7> : QueryJob
+    where T1 : struct
+    where T2 : struct
+    where T3 : struct
+    where T4 : struct
+    where T5 : struct
+    where T6 : struct
+    where T7 : struct
+{
+    internal            QueryChunks<T1, T2, T3, T4, T5, T6, T7> Chunks      => new (query);     // only for debugger
+    internal            QueryEntities                       Entities    => query.Entities;  // only for debugger
+    public  override    string                              ToString()  => query.GetQueryJobString();
+
+    [Browse(Never)]
+    private readonly    ArchetypeQuery<T1, T2, T3, T4, T5, T6, T7>                                                     query;      //  8
+    private readonly    Action<Chunk<T1>, Chunk<T2>, Chunk<T3>, Chunk<T4>, Chunk<T5>, Chunk<T6>, Chunk<T7>, ChunkEntities>    action;     //  8
+    [Browse(Never)]
+    private             QueryJobTask[]                                                                             jobTasks;   //  8
+
+
+    private class QueryJobTask : JobTask {
+        internal    Action<Chunk<T1>, Chunk<T2>, Chunk<T3>, Chunk<T4>, Chunk<T5>, Chunk<T6>, Chunk<T7>, ChunkEntities>    action;
+        internal    Chunks<T1, T2, T3, T4, T5, T6, T7>                                                             chunks;
+        
+        internal  override void ExecuteTask()  => action(chunks.Chunk1, chunks.Chunk2, chunks.Chunk3, chunks.Chunk4, chunks.Chunk5, chunks.Chunk6, chunks.Chunk7, chunks.Entities);
+    }
+    
+    internal QueryJob(
+        ArchetypeQuery<T1, T2, T3, T4, T5, T6, T7>                                                     query,
+        Action<Chunk<T1>, Chunk<T2>, Chunk<T3>, Chunk<T4>, Chunk<T5>, Chunk<T6>, Chunk<T7>, ChunkEntities>    action)
+    {
+        this.query  = query;
+        this.action = action;
+        jobRunner   = query.Store.JobRunner;
+    }
+    
+    public override void Run()
+    {
+        foreach (Chunks<T1, T2, T3, T4, T5, T6, T7> chunk in query.Chunks) {
+            action(chunk.Chunk1, chunk.Chunk2, chunk.Chunk3, chunk.Chunk4, chunk.Chunk5, chunk.Chunk6, chunk.Chunk7, chunk.Entities);
+        }
+    }
+    
+    /// <summary>Execute the query.
+    /// See <a href="https://friflo.gitbook.io/friflo.engine.ecs/documentation/query-optimization#parallel-query-job">Example.</a>.<br/>
+    /// All chunks having at least <see cref="QueryJob.MinParallelChunkLength"/> * <see cref="ParallelJobRunner.ThreadCount"/>
+    /// components are executed <see cref="JobExecution.Parallel"/>. 
+    /// </summary>
+    public override void RunParallel()
+    {
+        if (jobRunner == null) throw JobRunnerIsNullException();
+        var taskCount   = jobRunner.workerCount + 1;
+        
+        foreach (Chunks<T1, T2, T3, T4, T5, T6, T7> chunks in query.Chunks)
+        {
+            var chunkLength = chunks.Length;
+            if (ExecuteSequential(taskCount, chunkLength)) {
+                action(chunks.Chunk1, chunks.Chunk2, chunks.Chunk3, chunks.Chunk4, chunks.Chunk5, chunks.Chunk6, chunks.Chunk7, chunks.Entities);
+                continue;
+            }
+            var tasks = jobTasks;
+            if (tasks == null || tasks.Length < taskCount) {
+                tasks = jobTasks = new QueryJobTask[taskCount];
+                for (int n = 0; n < taskCount; n++) {
+                    tasks[n] = new QueryJobTask { action = action };
+                }
+            }
+            var sectionSize = GetSectionSize(chunkLength, taskCount, Multiple);
+            var start       = 0;
+            for (int taskIndex = 0; taskIndex < taskCount; taskIndex++)
+            {
+                var length = GetSectionLength (chunkLength, start, sectionSize);
+                if (length > 0) {
+                    tasks[taskIndex].chunks = new Chunks<T1, T2, T3, T4, T5, T6, T7>(chunks, start, length, taskIndex);
+                    start += sectionSize;
+                    continue;
+                }
+                for (; taskIndex < taskCount; taskIndex++) {
+                    tasks[taskIndex].chunks = new Chunks<T1, T2, T3, T4, T5, T6, T7>(chunks.Entities, taskIndex);
+                }
+                break;
+            }
+            jobRunner.ExecuteJob(this, tasks);
+        }
+    }
+    
+    public  override        int ParallelComponentMultiple   => Multiple;
+    private static readonly int Multiple                    = GetMultiple();
+    
+    private static int GetMultiple()
+    {
+        int lcm1 = StructPadding<T1>.ComponentMultiple;
+        int lcm2 = StructPadding<T2>.ComponentMultiple;
+        int lcm3 = StructPadding<T3>.ComponentMultiple;
+        int lcm4 = StructPadding<T4>.ComponentMultiple;
+        int lcm5 = StructPadding<T5>.ComponentMultiple;
+        int lcm6 = StructPadding<T6>.ComponentMultiple;
+        int lcm7 = StructPadding<T7>.ComponentMultiple;
+        
+        int lcm12   =   LeastComponentMultiple(lcm1,    lcm2);
+        int lcm34   =   LeastComponentMultiple(lcm3,    lcm4);
+        int lcm1234 =   LeastComponentMultiple(lcm12,   lcm34);
+        int lcm12345 =  LeastComponentMultiple(lcm1234, lcm5);
+        int lcm123456 = LeastComponentMultiple(lcm12345, lcm6);
+        return          LeastComponentMultiple(lcm123456, lcm7);
+    }
+}
diff --git a/src/ECS/Query/EntityStore.Query.cs b/src/ECS/Query/EntityStore.Query.cs
index dd875f906..354733f55 100644
--- a/src/ECS/Query/EntityStore.Query.cs
+++ b/src/ECS/Query/EntityStore.Query.cs
@@ -255,4 +255,105 @@ public ArchetypeQuery<T1, T2, T3, T4, T5> Query<T1, T2, T3, T4, T5> (QueryFilter
         return result;
     }
     #endregion
+    
+#region args - 6
+    /// <summary>
+    /// Create a reusable <see cref="ArchetypeQuery"/> for given component <paramref name="signature"/>.
+    /// </summary>
+    public ArchetypeQuery<T1, T2, T3, T4, T5, T6> Query<T1, T2, T3, T4, T5, T6> (Signature<T1, T2, T3, T4, T5, T6> signature)
+        where T1: struct, IComponent
+        where T2: struct, IComponent
+        where T3: struct, IComponent
+        where T4: struct, IComponent
+        where T5: struct, IComponent
+        where T6: struct, IComponent
+    {
+        var result = new ArchetypeQuery<T1, T2, T3, T4, T5, T6>(this, signature, null);
+        return result;
+    }
+    
+    /// <summary>
+    /// Create a reusable <see cref="ArchetypeQuery"/> for the given component types.<br/>
+    /// See <a href="https://friflo.gitbook.io/friflo.engine.ecs/documentation/query">Example.</a>
+    /// </summary>
+    public ArchetypeQuery<T1, T2, T3, T4, T5, T6> Query<T1, T2, T3, T4, T5, T6> ()
+        where T1: struct, IComponent
+        where T2: struct, IComponent
+        where T3: struct, IComponent
+        where T4: struct, IComponent
+        where T5: struct, IComponent
+        where T6: struct, IComponent
+    {
+        var result = new ArchetypeQuery<T1, T2, T3, T4, T5, T6>(this, Signature.Get<T1, T2, T3, T4, T5, T6>(), null);
+        return result;
+    }
+    
+    /// <summary>
+    /// Create a reusable <see cref="ArchetypeQuery"/> with given query <paramref name="filter"/>.<br/>
+    /// The filter attached to the query can be modified subsequently.
+    /// </summary>
+    public ArchetypeQuery<T1, T2, T3, T4, T5, T6> Query<T1, T2, T3, T4, T5, T6> (QueryFilter filter)
+        where T1 : struct, IComponent
+        where T2 : struct, IComponent
+        where T3 : struct, IComponent
+        where T4 : struct, IComponent
+        where T5 : struct, IComponent
+        where T6 : struct, IComponent
+    {
+        var result = new ArchetypeQuery<T1,T2,T3,T4,T5,T6>(this, Signature.Get<T1,T2,T3,T4,T5,T6>(), filter);
+        return result;
+    }
+#endregion
+
+#region args - 7
+    /// <summary>
+    /// Create a reusable <see cref="ArchetypeQuery"/> for given component <paramref name="signature"/>.
+    /// </summary>
+    public ArchetypeQuery<T1, T2, T3, T4, T5, T6, T7> Query<T1, T2, T3, T4, T5, T6, T7> (Signature<T1, T2, T3, T4, T5, T6, T7> signature)
+        where T1: struct, IComponent
+        where T2: struct, IComponent
+        where T3: struct, IComponent
+        where T4: struct, IComponent
+        where T5: struct, IComponent
+        where T6: struct, IComponent
+        where T7: struct, IComponent
+    {
+        var result = new ArchetypeQuery<T1, T2, T3, T4, T5, T6, T7>(this, signature, null);
+        return result;
+    }
+    
+    /// <summary>
+    /// Create a reusable <see cref="ArchetypeQuery"/> for the given component types.<br/>
+    /// See <a href="https://friflo.gitbook.io/friflo.engine.ecs/documentation/query">Example.</a>
+    /// </summary>
+    public ArchetypeQuery<T1, T2, T3, T4, T5, T6, T7> Query<T1, T2, T3, T4, T5, T6, T7> ()
+        where T1: struct, IComponent
+        where T2: struct, IComponent
+        where T3: struct, IComponent
+        where T4: struct, IComponent
+        where T5: struct, IComponent
+        where T6: struct, IComponent
+        where T7: struct, IComponent
+    {
+        var result = new ArchetypeQuery<T1, T2, T3, T4, T5, T6, T7>(this, Signature.Get<T1, T2, T3, T4, T5, T6, T7>(), null);
+        return result;
+    }
+    
+    /// <summary>
+    /// Create a reusable <see cref="ArchetypeQuery"/> with given query <paramref name="filter"/>.<br/>
+    /// The filter attached to the query can be modified subsequently.
+    /// </summary>
+    public ArchetypeQuery<T1, T2, T3, T4, T5, T6, T7> Query<T1, T2, T3, T4, T5, T6, T7> (QueryFilter filter)
+        where T1 : struct, IComponent
+        where T2 : struct, IComponent
+        where T3 : struct, IComponent
+        where T4 : struct, IComponent
+        where T5 : struct, IComponent
+        where T6 : struct, IComponent
+        where T7 : struct, IComponent
+    {
+        var result = new ArchetypeQuery<T1,T2,T3,T4,T5,T6, T7>(this, Signature.Get<T1,T2,T3,T4,T5,T6, T7>(), filter);
+        return result;
+    }
+#endregion
 }
diff --git a/src/ECS/Query/Signature.Indexes.cs b/src/ECS/Query/Signature.Indexes.cs
index 6c3f95605..b993b3168 100644
--- a/src/ECS/Query/Signature.Indexes.cs
+++ b/src/ECS/Query/Signature.Indexes.cs
@@ -23,8 +23,8 @@ internal readonly struct SignatureIndexes
     internal readonly   byte    T3;     // 1
     internal readonly   byte    T4;     // 1
     internal readonly   byte    T5;     // 1
-    private  readonly   byte    T6;     // 1
-    private  readonly   byte    T7;     // 1
+    internal readonly   byte    T6;     // 1
+    internal readonly   byte    T7;     // 1
     private  readonly   byte    T8;     // 1
     private  readonly   byte    T9;     // 1
     private  readonly   byte    T10;    // 1
diff --git a/src/ECS/Query/Signature.cs b/src/ECS/Query/Signature.cs
index 6d86a5669..a7264286d 100644
--- a/src/ECS/Query/Signature.cs
+++ b/src/ECS/Query/Signature.cs
@@ -135,6 +135,60 @@ public static Signature<T1, T2, T3, T4, T5> Get<T1, T2, T3, T4, T5>()
         return new Signature<T1, T2, T3, T4, T5>(indexes);
     }
     
+    /// <summary>
+    /// Returns a query <see cref="Signature{T1,T2,T3,T4,T5,T6}"/> containing the specified component types.<br/>
+    /// </summary>
+    /// <remarks>
+    /// It can be used to query entities with the specified component types with <see cref="EntityStore"/>.Query() methods.
+    /// </remarks>
+    public static Signature<T1, T2, T3, T4, T5, T6> Get<T1, T2, T3, T4, T5, T6>()
+        where T1 : struct, IComponent
+        where T2 : struct, IComponent
+        where T3 : struct, IComponent
+        where T4 : struct, IComponent
+        where T5 : struct, IComponent
+        where T6 : struct, IComponent
+    {
+        var schema  = EntityStoreBase.Static.EntitySchema;
+        var indexes = new SignatureIndexes(
+            T1: schema.CheckStructIndex(typeof(T1), StructInfo<T1>.Index),
+            T2: schema.CheckStructIndex(typeof(T2), StructInfo<T2>.Index),
+            T3: schema.CheckStructIndex(typeof(T3), StructInfo<T3>.Index),
+            T4: schema.CheckStructIndex(typeof(T4), StructInfo<T4>.Index),
+            T5: schema.CheckStructIndex(typeof(T5), StructInfo<T5>.Index),
+            T6: schema.CheckStructIndex(typeof(T6), StructInfo<T6>.Index)
+        );
+        return new Signature<T1, T2, T3, T4, T5, T6>(indexes);
+    }
+    
+    /// <summary>
+    /// Returns a query <see cref="Signature{T1,T2,T3,T4,T5,T6,T7}"/> containing the specified component types.<br/>
+    /// </summary>
+    /// <remarks>
+    /// It can be used to query entities with the specified component types with <see cref="EntityStore"/>.Query() methods.
+    /// </remarks>
+    public static Signature<T1, T2, T3, T4, T5, T6, T7> Get<T1, T2, T3, T4, T5, T6, T7>()
+        where T1 : struct, IComponent
+        where T2 : struct, IComponent
+        where T3 : struct, IComponent
+        where T4 : struct, IComponent
+        where T5 : struct, IComponent
+        where T6 : struct, IComponent
+        where T7 : struct, IComponent
+    {
+        var schema  = EntityStoreBase.Static.EntitySchema;
+        var indexes = new SignatureIndexes(
+            T1: schema.CheckStructIndex(typeof(T1), StructInfo<T1>.Index),
+            T2: schema.CheckStructIndex(typeof(T2), StructInfo<T2>.Index),
+            T3: schema.CheckStructIndex(typeof(T3), StructInfo<T3>.Index),
+            T4: schema.CheckStructIndex(typeof(T4), StructInfo<T4>.Index),
+            T5: schema.CheckStructIndex(typeof(T5), StructInfo<T5>.Index),
+            T6: schema.CheckStructIndex(typeof(T6), StructInfo<T6>.Index),
+            T7: schema.CheckStructIndex(typeof(T7), StructInfo<T7>.Index)
+        );
+        return new Signature<T1, T2, T3, T4, T5, T6, T7>(indexes);
+    }
+    
     internal static string GetSignatureString(in SignatureIndexes indexes) {
         return indexes.GetString("Signature: ");
     }
@@ -259,4 +313,145 @@ internal Signature(in SignatureIndexes signatureIndexes) {
     }
 }
 
+/// <summary>
+/// A Signature used to create a query using <see cref="EntityStoreBase.Query{T1,T2,T3,T4,T5,T6}(Signature{T1,T2,T3,T4,T5,T6})"/> with five components.
+/// </summary>
+public readonly struct Signature<T1, T2, T3, T4, T5, T6>
+    where T1 : struct
+    where T2 : struct
+    where T3 : struct
+    where T4 : struct
+    where T5 : struct
+    where T6 : struct
+{
+    /// <summary> Return the component types of the query signature. </summary>
+    public                              ComponentTypes      ComponentTypes  => new ComponentTypes(signatureIndexes);
+    
+    /// <summary> Gets the number component types of the query signature. </summary>
+    [Browse(Never)] public              int                 ComponentCount  => signatureIndexes.length;
+    
+    [Browse(Never)] internal readonly   SignatureIndexes    signatureIndexes;   // 16
+
+    public override string ToString() => Signature.GetSignatureString(signatureIndexes);
+
+    internal Signature(in SignatureIndexes signatureIndexes) {
+        this.signatureIndexes = signatureIndexes;
+    }
+}
+
+/// <summary>
+/// A Signature used to create a query using <see cref="EntityStoreBase.Query{T1,T2,T3,T4,T5,T6,T7}(Signature{T1,T2,T3,T4,T5,T6,T7})"/> with five components.
+/// </summary>
+public readonly struct Signature<T1, T2, T3, T4, T5, T6, T7>
+    where T1 : struct
+    where T2 : struct
+    where T3 : struct
+    where T4 : struct
+    where T5 : struct
+    where T6 : struct
+    where T7 : struct
+{
+    /// <summary> Return the component types of the query signature. </summary>
+    public                              ComponentTypes      ComponentTypes  => new ComponentTypes(signatureIndexes);
+    
+    /// <summary> Gets the number component types of the query signature. </summary>
+    [Browse(Never)] public              int                 ComponentCount  => signatureIndexes.length;
+    
+    [Browse(Never)] internal readonly   SignatureIndexes    signatureIndexes;   // 16
+
+    public override string ToString() => Signature.GetSignatureString(signatureIndexes);
+
+    internal Signature(in SignatureIndexes signatureIndexes) {
+        this.signatureIndexes = signatureIndexes;
+    }
+}
+
+/// <summary>
+/// A Signature used to create a query using <see cref="EntityStoreBase.Query{T1,T2,T3,T4,T5,T6,T7,T8}(Signature{T1,T2,T3,T4,T5,T6,T7,T8})"/> with five components.
+/// </summary>
+public readonly struct Signature<T1, T2, T3, T4, T5, T6, T7, T8>
+    where T1 : struct
+    where T2 : struct
+    where T3 : struct
+    where T4 : struct
+    where T5 : struct
+    where T6 : struct
+    where T7 : struct
+    where T8 : struct
+{
+    /// <summary> Return the component types of the query signature. </summary>
+    public                              ComponentTypes      ComponentTypes  => new ComponentTypes(signatureIndexes);
+    
+    /// <summary> Gets the number component types of the query signature. </summary>
+    [Browse(Never)] public              int                 ComponentCount  => signatureIndexes.length;
+    
+    [Browse(Never)] internal readonly   SignatureIndexes    signatureIndexes;   // 16
+
+    public override string ToString() => Signature.GetSignatureString(signatureIndexes);
+
+    internal Signature(in SignatureIndexes signatureIndexes) {
+        this.signatureIndexes = signatureIndexes;
+    }
+}
+
+
+/// <summary>
+/// A Signature used to create a query using <see cref="EntityStoreBase.Query{T1,T2,T3,T4,T5,T6,T7,T8,T9}(Signature{T1,T2,T3,T4,T5,T6,T7,T8,T9})"/> with five components.
+/// </summary>
+public readonly struct Signature<T1, T2, T3, T4, T5, T6, T7, T8, T9>
+    where T1 : struct
+    where T2 : struct
+    where T3 : struct
+    where T4 : struct
+    where T5 : struct
+    where T6 : struct
+    where T7 : struct
+    where T8 : struct
+    where T9 : struct
+{
+    /// <summary> Return the component types of the query signature. </summary>
+    public                              ComponentTypes      ComponentTypes  => new ComponentTypes(signatureIndexes);
+    
+    /// <summary> Gets the number component types of the query signature. </summary>
+    [Browse(Never)] public              int                 ComponentCount  => signatureIndexes.length;
+    
+    [Browse(Never)] internal readonly   SignatureIndexes    signatureIndexes;   // 16
+
+    public override string ToString() => Signature.GetSignatureString(signatureIndexes);
+
+    internal Signature(in SignatureIndexes signatureIndexes) {
+        this.signatureIndexes = signatureIndexes;
+    }
+}
+
+/// <summary>
+/// A Signature used to create a query using <see cref="EntityStoreBase.Query{T1,T2,T3,T4,T5,T6,T7,T8,T9,10}(Signature{T1,T2,T3,T4,T5,T6,T7,T8,T9,10})"/> with five components.
+/// </summary>
+public readonly struct Signature<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>
+    where T1 : struct
+    where T2 : struct
+    where T3 : struct
+    where T4 : struct
+    where T5 : struct
+    where T6 : struct
+    where T7 : struct
+    where T8 : struct
+    where T9 : struct
+    where T10 : struct
+{
+    /// <summary> Return the component types of the query signature. </summary>
+    public                              ComponentTypes      ComponentTypes  => new ComponentTypes(signatureIndexes);
+    
+    /// <summary> Gets the number component types of the query signature. </summary>
+    [Browse(Never)] public              int                 ComponentCount  => signatureIndexes.length;
+    
+    [Browse(Never)] internal readonly   SignatureIndexes    signatureIndexes;   // 16
+
+    public override string ToString() => Signature.GetSignatureString(signatureIndexes);
+
+    internal Signature(in SignatureIndexes signatureIndexes) {
+        this.signatureIndexes = signatureIndexes;
+    }
+}
+
 #endregion
diff --git a/src/ECS/Systems/Query/Arg.6.cs b/src/ECS/Systems/Query/Arg.6.cs
new file mode 100644
index 000000000..0f1907e61
--- /dev/null
+++ b/src/ECS/Systems/Query/Arg.6.cs
@@ -0,0 +1,41 @@
+// Copyright (c) Ullrich Praetz - https://github.com/friflo. All rights reserved.
+// See LICENSE file in the project root for full license information.
+
+using static System.Diagnostics.DebuggerBrowsableState;
+using Browse = System.Diagnostics.DebuggerBrowsableAttribute;
+// Hard Rule! file must not have any dependency a to a specific game engine. E.g. Unity, Godot, Monogame, ...
+
+// ReSharper disable ConvertToPrimaryConstructor
+// ReSharper disable ConvertToAutoPropertyWithPrivateSetter
+// ReSharper disable once CheckNamespace
+namespace Friflo.Engine.ECS.Systems;
+
+/// <summary>
+/// A query system returning entities with the specified component types via its <see cref="Query"/> property.
+/// </summary>
+public abstract class QuerySystem<T1, T2, T3, T4, T5, T6> : QuerySystemBase
+    where T1 : struct, IComponent
+    where T2 : struct, IComponent
+    where T3 : struct, IComponent
+    where T4 : struct, IComponent
+    where T5 : struct, IComponent
+    where T6 : struct, IComponent
+{
+    /// <summary> Return all entities matching the <see cref="Query"/>. </summary>
+    protected       ArchetypeQuery<T1, T2, T3, T4, T5, T6>  Query       => query;
+    
+    public override string                              ToString()  => GetString(Signature.Get<T1,T2,T3,T4,T5,T6>().signatureIndexes);
+    
+#region fields
+    [Browse(Never)] private     ArchetypeQuery<T1, T2, T3, T4, T5, T6>    query;
+    #endregion
+    
+    protected QuerySystem() : base (Generic<T1, T2, T3, T4, T5, T6>.ComponentTypes) { }
+    
+    internal override void SetQuery(ArchetypeQuery query) { this.query = (ArchetypeQuery<T1, T2, T3, T4, T5, T6>)query; }
+    
+    internal override ArchetypeQuery  CreateQuery(EntityStore store) {
+        return store.Query<T1,T2,T3,T4,T5,T6>(Filter);
+    }
+
+}
diff --git a/src/ECS/Systems/Query/Arg.7.cs b/src/ECS/Systems/Query/Arg.7.cs
new file mode 100644
index 000000000..facce2eac
--- /dev/null
+++ b/src/ECS/Systems/Query/Arg.7.cs
@@ -0,0 +1,42 @@
+// Copyright (c) Ullrich Praetz - https://github.com/friflo. All rights reserved.
+// See LICENSE file in the project root for full license information.
+
+using static System.Diagnostics.DebuggerBrowsableState;
+using Browse = System.Diagnostics.DebuggerBrowsableAttribute;
+// Hard Rule! file must not have any dependency a to a specific game engine. E.g. Unity, Godot, Monogame, ...
+
+// ReSharper disable ConvertToPrimaryConstructor
+// ReSharper disable ConvertToAutoPropertyWithPrivateSetter
+// ReSharper disable once CheckNamespace
+namespace Friflo.Engine.ECS.Systems;
+
+/// <summary>
+/// A query system returning entities with the specified component types via its <see cref="Query"/> property.
+/// </summary>
+public abstract class QuerySystem<T1, T2, T3, T4, T5, T6, T7> : QuerySystemBase
+    where T1 : struct, IComponent
+    where T2 : struct, IComponent
+    where T3 : struct, IComponent
+    where T4 : struct, IComponent
+    where T5 : struct, IComponent
+    where T6 : struct, IComponent
+    where T7 : struct, IComponent
+{
+    /// <summary> Return all entities matching the <see cref="Query"/>. </summary>
+    protected       ArchetypeQuery<T1, T2, T3, T4, T5, T6, T7>  Query       => query;
+    
+    public override string                              ToString()  => GetString(Signature.Get<T1,T2,T3,T4,T5,T6,T7>().signatureIndexes);
+    
+#region fields
+    [Browse(Never)] private     ArchetypeQuery<T1, T2, T3, T4, T5, T6, T7>    query;
+    #endregion
+    
+    protected QuerySystem() : base (Generic<T1, T2, T3, T4, T5, T6, T7>.ComponentTypes) { }
+    
+    internal override void SetQuery(ArchetypeQuery query) { this.query = (ArchetypeQuery<T1, T2, T3, T4, T5, T6, T7>)query; }
+    
+    internal override ArchetypeQuery  CreateQuery(EntityStore store) {
+        return store.Query<T1,T2,T3,T4,T5,T6,T7>(Filter);
+    }
+
+}
diff --git a/src/Tests-internal/ECS/Test_QueryJob.cs b/src/Tests-internal/ECS/Test_QueryJob.cs
index 3556f58cf..8cd14a2fe 100644
--- a/src/Tests-internal/ECS/Test_QueryJob.cs
+++ b/src/Tests-internal/ECS/Test_QueryJob.cs
@@ -24,7 +24,7 @@ private static void AssertMissingRunner(QueryJob job)
     public static void Test_QueryJob_ToString()
     {
         var store   = new EntityStore(PidType.UsePidAsId);
-        var types   = ComponentTypes.Get<MyComponent1, MyComponent2, Position, Rotation, Scale3>();
+        var types   = ComponentTypes.Get<MyComponent1, MyComponent2, MyComponent3, MyComponent4, Position, Rotation, Scale3>();
         var archetype   = store.GetArchetype(types);
         for (int n = 0; n < 32; n++) {
             archetype.CreateEntity();
@@ -59,7 +59,20 @@ public static void Test_QueryJob_ToString()
             AreEqual(32, job.Entities.Count);
             AreEqual("QueryJob [MyComponent1, MyComponent2, Position, Rotation, Scale3]", job.ToString());
             AssertMissingRunner(job);
+        } {
+            var job = store.Query<MyComponent1, MyComponent2, MyComponent3, Position, Rotation, Scale3>().ForEach((_, _, _, _, _, _, _) => { });
+            AreEqual(32, job.Chunks.Count);
+            AreEqual(32, job.Entities.Count);
+            AreEqual("QueryJob [MyComponent1, MyComponent2, MyComponent3, Position, Rotation, Scale3]", job.ToString());
+            AssertMissingRunner(job);
         }
+        // {
+        //     var job = store.Query<MyComponent1, MyComponent2, MyComponent3, MyComponent4, Position, Rotation, Scale3>().ForEach((_, _, _, _, _, _, _, _) => { });
+        //     AreEqual(32, job.Chunks.Count);
+        //     AreEqual(32, job.Entities.Count);
+        //     AreEqual("QueryJob [MyComponent1, MyComponent2, MyComponent3, MyComponent4, Position, Rotation, Scale3]", job.ToString());
+        //     AssertMissingRunner(job);
+        // }
     }
 
     [Test]
diff --git a/src/Tests/Boost/Test_Query_Each.cs b/src/Tests/Boost/Test_Query_Each.cs
index c21db81af..73144fda6 100644
--- a/src/Tests/Boost/Test_Query_Each.cs
+++ b/src/Tests/Boost/Test_Query_Each.cs
@@ -138,6 +138,58 @@ public static void Test_Query_Chunks_Each5()
         }
     }
     
+    [Test]
+    public static void Test_Query_Each6()
+    {
+        var store   = CreateStore();
+        var query   = store.Query<MyComponent1, MyComponent2, MyComponent3, MyComponent4, MyComponent5, MyComponent6>();
+        var each    = query.Each(new Each6());
+        foreach (var entity in store.Entities) {
+            Mem.AreEqual(31, entity.GetComponent<MyComponent1>().a);
+        }
+        Mem.AreEqual(100, each.count);
+    }
+    
+    [Test]
+    public static void Test_Query_Chunks_Each6()
+    {
+        var store   = CreateStore();
+        var query = store.Query<MyComponent1, MyComponent2, MyComponent3, MyComponent4, MyComponent5, MyComponent6>();
+        var each    = new Each6();
+        foreach (var chunk in query.Chunks) {
+            chunk.Each(ref each);
+        }
+        foreach (var entity in store.Entities) {
+            Mem.AreEqual(31, entity.GetComponent<MyComponent1>().a);
+        }
+    }
+    
+    [Test]
+    public static void Test_Query_Each7()
+    {
+        var store   = CreateStore();
+        var query   = store.Query<MyComponent1, MyComponent2, MyComponent3, MyComponent4, MyComponent5, MyComponent6, MyComponent7>();
+        var each    = query.Each(new Each7());
+        foreach (var entity in store.Entities) {
+            Mem.AreEqual(63, entity.GetComponent<MyComponent1>().a);
+        }
+        Mem.AreEqual(100, each.count);
+    }
+    
+    [Test]
+    public static void Test_Query_Chunks_Each7()
+    {
+        var store   = CreateStore();
+        var query = store.Query<MyComponent1, MyComponent2, MyComponent3, MyComponent4, MyComponent5, MyComponent6, MyComponent7>();
+        var each    = new Each7();
+        foreach (var chunk in query.Chunks) {
+            chunk.Each(ref each);
+        }
+        foreach (var entity in store.Entities) {
+            Mem.AreEqual(63, entity.GetComponent<MyComponent1>().a);
+        }
+    }
+    
     
     private static EntityStore CreateStore()
     {
@@ -148,7 +200,9 @@ private static EntityStore CreateStore()
                 new MyComponent2{ b = 1 },
                 new MyComponent3{ b = 2 },
                 new MyComponent4{ b = 4 },
-                new MyComponent5{ b = 8 });
+                new MyComponent5{ b = 8 },
+                new MyComponent6{ b = 16 },
+                new MyComponent7{ b = 32 });
         }
         return store;
     }
@@ -197,5 +251,24 @@ public void Execute(ref MyComponent1 c1, ref MyComponent2 c2, ref MyComponent3 c
             count++;
         }
     }
+    
+    private struct Each6 : IEach<MyComponent1, MyComponent2, MyComponent3, MyComponent4, MyComponent5, MyComponent6>
+    {
+        internal int count;
+        public void Execute(ref MyComponent1 c1, ref MyComponent2 c2, ref MyComponent3 c3, ref MyComponent4 c4, ref MyComponent5 c5, ref MyComponent6 c6) {
+            c1.a = c2.b + c3.b + c4.b + c5.b + c6.b;
+            count++;
+        }
+    }
+    
+    private struct Each7 : IEach<MyComponent1, MyComponent2, MyComponent3, MyComponent4, MyComponent5, MyComponent6, MyComponent7>
+    {
+        internal int count;
+        public void Execute(ref MyComponent1 c1, ref MyComponent2 c2, ref MyComponent3 c3, ref MyComponent4 c4, ref MyComponent5 c5, ref MyComponent6 c6, ref MyComponent7 c7)
+        {
+            c1.a = c2.b + c3.b + c4.b + c5.b + c6.b + c7.b;
+            count++;
+        }
+    }
 }
 }
\ No newline at end of file
diff --git a/src/Tests/Boost/Test_Query_EachEntity.cs b/src/Tests/Boost/Test_Query_EachEntity.cs
index 311cc773f..b88c896be 100644
--- a/src/Tests/Boost/Test_Query_EachEntity.cs
+++ b/src/Tests/Boost/Test_Query_EachEntity.cs
@@ -117,7 +117,7 @@ public static void Test_Query_Chunks_EachEntity4()
     public static void Test_Query_EachEntity5()
     {
         var store   = CreateStore();
-        var query   = store.Query<MyComponent1, MyComponent2, MyComponent3, MyComponent4, MyComponent5>();
+        var query = store.Query<MyComponent1, MyComponent2, MyComponent3, MyComponent4, MyComponent5>();
         var each    = query.EachEntity(new Each5());
         foreach (var entity in store.Entities) {
             Mem.AreEqual(15, entity.GetComponent<MyComponent1>().a);
@@ -139,6 +139,58 @@ public static void Test_Query_Chunks_EachEntity5()
         }
     }
     
+    [Test]
+    public static void Test_Query_EachEntity6()
+    {
+        var store   = CreateStore();
+        var query   = store.Query<MyComponent1, MyComponent2, MyComponent3, MyComponent4, MyComponent5, MyComponent6>();
+        var each    = query.EachEntity(new Each6());
+        foreach (var entity in store.Entities) {
+            Mem.AreEqual(31, entity.GetComponent<MyComponent1>().a);
+        }
+        Mem.AreEqual(100, each.count);
+    }
+    
+    [Test]
+    public static void Test_Query_Chunks_EachEntity6()
+    {
+        var store   = CreateStore();
+        var query   = store.Query<MyComponent1, MyComponent2, MyComponent3, MyComponent4, MyComponent5, MyComponent6>();
+        var each    = new Each6();
+        foreach (var chunk in query.Chunks) {
+            chunk.EachEntity(ref each);
+        }
+        foreach (var entity in store.Entities) {
+            Mem.AreEqual(31, entity.GetComponent<MyComponent1>().a);
+        }
+    }
+    
+    [Test]
+    public static void Test_Query_EachEntity7()
+    {
+        var store   = CreateStore();
+        var query   = store.Query<MyComponent1, MyComponent2, MyComponent3, MyComponent4, MyComponent5, MyComponent6, MyComponent7>();
+        var each    = query.EachEntity(new Each7());
+        foreach (var entity in store.Entities) {
+            Mem.AreEqual(63, entity.GetComponent<MyComponent1>().a);
+        }
+        Mem.AreEqual(100, each.count);
+    }
+    
+    [Test]
+    public static void Test_Query_Chunks_EachEntity7()
+    {
+        var store   = CreateStore();
+        var query   = store.Query<MyComponent1, MyComponent2, MyComponent3, MyComponent4, MyComponent5, MyComponent6, MyComponent7>();
+        var each    = new Each7();
+        foreach (var chunk in query.Chunks) {
+            chunk.EachEntity(ref each);
+        }
+        foreach (var entity in store.Entities) {
+            Mem.AreEqual(63, entity.GetComponent<MyComponent1>().a);
+        }
+    }
+    
     
     private static EntityStore CreateStore()
     {
@@ -149,7 +201,9 @@ private static EntityStore CreateStore()
                 new MyComponent2{ b = 1 },
                 new MyComponent3{ b = 2 },
                 new MyComponent4{ b = 4 },
-                new MyComponent5{ b = 8 });
+                new MyComponent5{ b = 8 },
+                new MyComponent6{ b = 16 },
+                new MyComponent7{ b = 32 });
         }
         return store;
     }
@@ -198,5 +252,23 @@ public void Execute(ref MyComponent1 c1, ref MyComponent2 c2, ref MyComponent3 c
             Mem.AreEqual(++count, id);
         }
     }
+    
+    private struct Each6 : IEachEntity<MyComponent1, MyComponent2, MyComponent3, MyComponent4, MyComponent5, MyComponent6>
+    {
+        internal int count;
+        public void Execute(ref MyComponent1 c1, ref MyComponent2 c2, ref MyComponent3 c3, ref MyComponent4 c4, ref MyComponent5 c5, ref MyComponent6 c6, int id) {
+            c1.a = c2.b + c3.b + c4.b + c5.b + c6.b;
+            Mem.AreEqual(++count, id);
+        }
+    }
+    
+    private struct Each7 : IEachEntity<MyComponent1, MyComponent2, MyComponent3, MyComponent4, MyComponent5, MyComponent6, MyComponent7>
+    {
+        internal int count;
+        public void Execute(ref MyComponent1 c1, ref MyComponent2 c2, ref MyComponent3 c3, ref MyComponent4 c4, ref MyComponent5 c5, ref MyComponent6 c6, ref MyComponent7 c7, int id) {
+            c1.a = c2.b + c3.b + c4.b + c5.b + c6.b + c7.b;
+            Mem.AreEqual(++count, id);
+        }
+    }
 }
 }
\ No newline at end of file
diff --git a/src/Tests/ECS/Arch/Test_Query.cs b/src/Tests/ECS/Arch/Test_Query.cs
index 410e3ba2e..8cec059e5 100644
--- a/src/Tests/ECS/Arch/Test_Query.cs
+++ b/src/Tests/ECS/Arch/Test_Query.cs
@@ -236,18 +236,21 @@ public static void Test_Signature_Query()
         var sig3 = Signature.Get<Position, Rotation, Scale3>();
         var sig4 = Signature.Get<Position, Rotation, Scale3, MyComponent1>();
         var sig5 = Signature.Get<Position, Rotation, Scale3, MyComponent1, MyComponent2>();
+        var sig6 = Signature.Get<Position, Rotation, Scale3, MyComponent1, MyComponent2, MyComponent3>();
         //
         var query1 =    store.Query(sig1);
         var query2 =    store.Query(sig2);
         var query3 =    store.Query(sig3);
         var query4 =    store.Query(sig4);
         var query5 =    store.Query(sig5);
+        var query6 =    store.Query(sig6);
         
         AreEqual("Query: [Position]  Count: 0",                                               query1.ToString());
         AreEqual("Query: [Position, Rotation]  Count: 0",                                     query2.ToString());
         AreEqual("Query: [Position, Rotation, Scale3]  Count: 0",                             query3.ToString());
         AreEqual("Query: [Position, Rotation, Scale3, MyComponent1]  Count: 0",               query4.ToString());
         AreEqual("Query: [Position, Rotation, Scale3, MyComponent1, MyComponent2]  Count: 0", query5.ToString());
+        AreEqual("Query: [Position, Rotation, Scale3, MyComponent1, MyComponent2, MyComponent3]  Count: 0", query6.ToString());
         
         AreEqual(0, query1.Archetypes.Length);
         AreEqual(0, query2.Archetypes.Length);
@@ -289,6 +292,14 @@ public static void Test_Signature_Query()
         AreEqual(3, query3.Archetypes.Length);
         AreEqual(2, query4.Archetypes.Length);
         AreEqual(1, query5.Archetypes.Length);
+        
+        entity.AddComponent<MyComponent3>();
+        AreEqual(6, query1.Archetypes.Length);
+        AreEqual(5, query2.Archetypes.Length);
+        AreEqual(4, query3.Archetypes.Length);
+        AreEqual(3, query4.Archetypes.Length);
+        AreEqual(2, query5.Archetypes.Length);
+        AreEqual(1, query6.Archetypes.Length);
     }
     
     [Test]
diff --git a/src/Tests/ECS/Arch/Test_QueryComponents.cs b/src/Tests/ECS/Arch/Test_QueryComponents.cs
index e8fa47abe..c12f037d2 100644
--- a/src/Tests/ECS/Arch/Test_QueryComponents.cs
+++ b/src/Tests/ECS/Arch/Test_QueryComponents.cs
@@ -1,4 +1,5 @@
-using System.Collections.Generic;
+using System;
+using System.Collections.Generic;
 using Friflo.Engine.ECS;
 using NUnit.Framework;
 using static NUnit.Framework.Assert;
@@ -14,6 +15,8 @@ private struct Comp2 : IComponent { }
     private struct Comp3 : IComponent { }
     private struct Comp4 : IComponent { }
     private struct Comp5 : IComponent { }
+    private struct Comp6 : IComponent { }
+    private struct Comp7 : IComponent { }
     
     [Test]
     public static void Test_QueryComponents_AllComponents()
@@ -23,19 +26,25 @@ public static void Test_QueryComponents_AllComponents()
         var query   = store.Query(sig);
         
         query = query.AllComponents(ComponentTypes.Get<Comp1>());
-        AssertResult("2, 7, 8, 9, 10",  query);
+        AssertResult("11, 102, 103, 104, 105, 106, 107",  query);
         
         query = query.AllComponents(ComponentTypes.Get<Comp1, Comp2>());
-        AssertResult("7, 8, 9, 10",     query);
+        AssertResult("102, 103, 104, 105, 106, 107",     query);
         
         query = query.AllComponents(ComponentTypes.Get<Comp1, Comp2, Comp3>());
-        AssertResult("8, 9, 10",        query);
+        AssertResult("103, 104, 105, 106, 107",        query);
         
         query = query.AllComponents(ComponentTypes.Get<Comp1, Comp2, Comp3, Comp4>());
-        AssertResult("9, 10",           query);
+        AssertResult("104, 105, 106, 107",           query);
 
         query = query.AllComponents(ComponentTypes.Get<Comp1, Comp2, Comp3, Comp4, Comp5>());
-        AssertResult("10",              query);
+        AssertResult("105, 106, 107",               query);
+        
+        query = query.AllComponents(ComponentTypes.Get<Comp1, Comp2, Comp3, Comp4, Comp5, Comp6>());
+        AssertResult("106, 107",                   query);
+        
+        query = query.AllComponents(ComponentTypes.Get<Comp1, Comp2, Comp3, Comp4, Comp5, Comp6, Comp7>());
+        AssertResult("107",                   query);
     }
     
     [Test]
@@ -46,19 +55,25 @@ public static void Test_QueryComponents_AnyComponents()
         var query   = store.Query(sig);
         
         query = query.AnyComponents(ComponentTypes.Get<Comp1>());
-        AssertResult("2, 7, 8, 9, 10",  query);
+        AssertResult("11, 102, 103, 104, 105, 106, 107",  query);
         
         query = query.AnyComponents(ComponentTypes.Get<Comp2>());
-        AssertResult("3, 7, 8, 9, 10",  query);
+        AssertResult("12, 102, 103, 104, 105, 106, 107",  query);
         
         query = query.AnyComponents(ComponentTypes.Get<Comp3>());
-        AssertResult("4, 8, 9, 10",     query);
+        AssertResult("13, 103, 104, 105, 106, 107",     query);
         
         query = query.AnyComponents(ComponentTypes.Get<Comp4>());
-        AssertResult("5, 9, 10",        query);
+        AssertResult("14, 104, 105, 106, 107",        query);
 
         query = query.AnyComponents(ComponentTypes.Get<Comp5>());
-        AssertResult("6, 10",           query);
+        AssertResult("15, 105, 106, 107",           query);
+        
+        query = query.AnyComponents(ComponentTypes.Get<Comp6>());
+        AssertResult("16, 106, 107",           query);
+        
+        query = query.AnyComponents(ComponentTypes.Get<Comp7>());
+        AssertResult("17, 107",           query);
     }
 
     [Test]
@@ -71,19 +86,25 @@ public static void Test_QueryComponents_AnyComponents_AllComponents()
         var all = ComponentTypes.Get<Comp2, Comp3>(); // entities: 8, 9, 10
         
         query = query.AnyComponents(ComponentTypes.Get<Comp1>()).AllComponents(all);
-        AssertResult("2, 7, 8, 9, 10",  query);
+        AssertResult("11, 102, 103, 104, 105, 106, 107",  query);
         
         query = query.AnyComponents(ComponentTypes.Get<Comp2>()).AllComponents(all);
-        AssertResult("3, 7, 8, 9, 10",  query);
+        AssertResult("12, 102, 103, 104, 105, 106, 107",  query);
         
         query = query.AnyComponents(ComponentTypes.Get<Comp3>()).AllComponents(all);
-        AssertResult("4, 8, 9, 10",     query);
+        AssertResult("13, 103, 104, 105, 106, 107",     query);
         
         query = query.AnyComponents(ComponentTypes.Get<Comp4>()).AllComponents(all);
-        AssertResult("5, 8, 9, 10",     query);
+        AssertResult("14, 103, 104, 105, 106, 107",     query);
 
         query = query.AnyComponents(ComponentTypes.Get<Comp5>()).AllComponents(all);
-        AssertResult("6, 8, 9, 10",     query);
+        AssertResult("15, 103, 104, 105, 106, 107",     query);
+        
+        query = query.AnyComponents(ComponentTypes.Get<Comp6>()).AllComponents(all);
+        AssertResult("16, 103, 104, 105, 106, 107",     query);
+        
+        query = query.AnyComponents(ComponentTypes.Get<Comp7>()).AllComponents(all);
+        AssertResult("17, 103, 104, 105, 106, 107",     query);
     }
     
     [Test]
@@ -94,19 +115,25 @@ public static void Test_QueryComponents_WithoutAllComponents()
         var query   = store.Query(sig);
         
         query = query.WithoutAllComponents(ComponentTypes.Get<Comp1>());
-        AssertResult("1, 3, 4, 5, 6",               query);
+        AssertResult("1, 12, 13, 14, 15, 16, 17",               query);
         
         query = query.WithoutAllComponents(ComponentTypes.Get<Comp1, Comp2>());
-        AssertResult("1, 2, 3, 4, 5, 6",            query);
+        AssertResult("1, 11, 12, 13, 14, 15, 16, 17",            query);
         
         query = query.WithoutAllComponents(ComponentTypes.Get<Comp1, Comp2, Comp3>());
-        AssertResult("1, 2, 3, 4, 5, 6, 7",         query);
+        AssertResult("1, 11, 12, 13, 14, 15, 16, 17, 102",         query);
         
         query = query.WithoutAllComponents(ComponentTypes.Get<Comp1, Comp2, Comp3, Comp4>());
-        AssertResult("1, 2, 3, 4, 5, 6, 7, 8",      query);
+        AssertResult("1, 11, 12, 13, 14, 15, 16, 17, 102, 103",      query);
 
         query = query.WithoutAllComponents(ComponentTypes.Get<Comp1, Comp2, Comp3, Comp4, Comp5>());
-        AssertResult("1, 2, 3, 4, 5, 6, 7, 8, 9",   query);
+        AssertResult("1, 11, 12, 13, 14, 15, 16, 17, 102, 103, 104",   query);
+        
+        query = query.WithoutAllComponents(ComponentTypes.Get<Comp1, Comp2, Comp3, Comp4, Comp5, Comp6>());
+        AssertResult("1, 11, 12, 13, 14, 15, 16, 17, 102, 103, 104, 105",   query);
+        
+        query = query.WithoutAllComponents(ComponentTypes.Get<Comp1, Comp2, Comp3, Comp4, Comp5, Comp6, Comp7>());
+        AssertResult("1, 11, 12, 13, 14, 15, 16, 17, 102, 103, 104, 105, 106",   query);
     }
     
     [Test]
@@ -117,19 +144,25 @@ public static void Test_QueryComponents_WithoutAnyComponents()
         var query   = store.Query(sig);
         
         query = query.WithoutAnyComponents(ComponentTypes.Get<Comp1>());
-        AssertResult("1, 3, 4, 5, 6",           query);
+        AssertResult("1, 12, 13, 14, 15, 16, 17",           query);
         
         query = query.WithoutAnyComponents(ComponentTypes.Get<Comp2>());
-        AssertResult("1, 2, 4, 5, 6",           query);
+        AssertResult("1, 11, 13, 14, 15, 16, 17",           query);
         
         query = query.WithoutAnyComponents(ComponentTypes.Get<Comp3>());
-        AssertResult("1, 2, 3, 5, 6, 7",        query);
+        AssertResult("1, 11, 12, 14, 15, 16, 17, 102",        query);
         
         query = query.WithoutAnyComponents(ComponentTypes.Get<Comp4>());
-        AssertResult("1, 2, 3, 4, 6, 7, 8",     query);
+        AssertResult("1, 11, 12, 13, 15, 16, 17, 102, 103",     query);
 
         query = query.WithoutAnyComponents(ComponentTypes.Get<Comp5>());
-        AssertResult("1, 2, 3, 4, 5, 7, 8, 9",  query);
+        AssertResult("1, 11, 12, 13, 14, 16, 17, 102, 103, 104",  query);
+        
+        query = query.WithoutAnyComponents(ComponentTypes.Get<Comp6>());
+        AssertResult("1, 11, 12, 13, 14, 15, 17, 102, 103, 104, 105",  query);
+        
+        query = query.WithoutAnyComponents(ComponentTypes.Get<Comp7>());
+        AssertResult("1, 11, 12, 13, 14, 15, 16, 102, 103, 104, 105, 106",  query);
     }
     
     [Test]
@@ -139,27 +172,28 @@ public static void Test_QueryComponents_WithoutAnyComponents_WithoutAllComponent
         var sig     = Signature.Get<Position>();
         var query   = store.Query(sig);
         
-        var all = ComponentTypes.Get<Comp2, Comp3>(); // entities: 8, 9, 10
+        var all = ComponentTypes.Get<Comp2, Comp3>(); 
         
-        // without: 1, 3, 4, 5, 6
         query = query.WithoutAnyComponents(ComponentTypes.Get<Comp1>()).WithoutAllComponents(all);
-        AssertResult("1, 3, 4, 5, 6",           query);
+        AssertResult("1, 12, 13, 14, 15, 16, 17",           query);
         
-        // without: 1, 2, 4, 5, 6
         query = query.WithoutAnyComponents(ComponentTypes.Get<Comp2>()).WithoutAllComponents(all);
-        AssertResult("1, 2, 4, 5, 6",           query);
+        AssertResult("1, 11, 13, 14, 15, 16, 17",           query);
         
-        // without: 1, 2, 3, 5, 6, 7
         query = query.WithoutAnyComponents(ComponentTypes.Get<Comp3>()).WithoutAllComponents(all);
-        AssertResult("1, 2, 3, 5, 6, 7",        query);
+        AssertResult("1, 11, 12, 14, 15, 16, 17, 102",        query);
         
-        // without: 1, 2, 3, 4, 6, 7, 8
         query = query.WithoutAnyComponents(ComponentTypes.Get<Comp4>()).WithoutAllComponents(all);
-        AssertResult("1, 2, 3, 4, 6, 7",        query);
+        AssertResult("1, 11, 12, 13, 15, 16, 17, 102",        query);
 
-        // without: 1, 2, 3, 4, 5, 7, 8, 9
         query = query.WithoutAnyComponents(ComponentTypes.Get<Comp5>()).WithoutAllComponents(all);
-        AssertResult("1, 2, 3, 4, 5, 7",        query);
+        AssertResult("1, 11, 12, 13, 14, 16, 17, 102",        query);
+        
+        query = query.WithoutAnyComponents(ComponentTypes.Get<Comp6>()).WithoutAllComponents(all);
+        AssertResult("1, 11, 12, 13, 14, 15, 17, 102",        query);
+        
+        query = query.WithoutAnyComponents(ComponentTypes.Get<Comp7>()).WithoutAllComponents(all);
+        AssertResult("1, 11, 12, 13, 14, 15, 16, 102",        query);
     }
     
     private static EntityStore CreateTestStore()
@@ -167,16 +201,20 @@ private static EntityStore CreateTestStore()
         var store   = new EntityStore(PidType.UsePidAsId);
         CreateEntity(store,  1, new ComponentTypes());    
         
-        CreateEntity(store,  2, ComponentTypes.Get<Comp1>());
-        CreateEntity(store,  3, ComponentTypes.Get<Comp2>());
-        CreateEntity(store,  4, ComponentTypes.Get<Comp3>());
-        CreateEntity(store,  5, ComponentTypes.Get<Comp4>());
-        CreateEntity(store,  6, ComponentTypes.Get<Comp5>());
-        
-        CreateEntity(store,  7, ComponentTypes.Get<Comp1, Comp2>());
-        CreateEntity(store,  8, ComponentTypes.Get<Comp1, Comp2, Comp3>());
-        CreateEntity(store,  9, ComponentTypes.Get<Comp1, Comp2, Comp3, Comp4>());
-        CreateEntity(store, 10, ComponentTypes.Get<Comp1, Comp2, Comp3, Comp4, Comp5>());
+        CreateEntity(store,  11,  ComponentTypes.Get<Comp1>());
+        CreateEntity(store,  12,  ComponentTypes.Get<Comp2>());
+        CreateEntity(store,  13,  ComponentTypes.Get<Comp3>());
+        CreateEntity(store,  14,  ComponentTypes.Get<Comp4>());
+        CreateEntity(store,  15,  ComponentTypes.Get<Comp5>());
+        CreateEntity(store,  16,  ComponentTypes.Get<Comp6>());
+        CreateEntity(store,  17,  ComponentTypes.Get<Comp7>());
+        
+        CreateEntity(store,  102, ComponentTypes.Get<Comp1, Comp2>());
+        CreateEntity(store,  103, ComponentTypes.Get<Comp1, Comp2, Comp3>());
+        CreateEntity(store,  104, ComponentTypes.Get<Comp1, Comp2, Comp3, Comp4>());
+        CreateEntity(store,  105, ComponentTypes.Get<Comp1, Comp2, Comp3, Comp4, Comp5>());
+        CreateEntity(store,  106, ComponentTypes.Get<Comp1, Comp2, Comp3, Comp4, Comp5, Comp6>());
+        CreateEntity(store,  107, ComponentTypes.Get<Comp1, Comp2, Comp3, Comp4, Comp5, Comp6, Comp7>());
         return store;
     }
     
@@ -221,19 +259,19 @@ public static void Test_QueryComponents_overloads_AllComponents_AnyComponents()
         var any = ComponentTypes.Get<Comp1>();
         
         var query = store.Query().AllComponents(all).AnyComponents(any);
-        AssertResult("2, 7, 8, 9, 10",  query);
+        AssertResult("11, 102, 103, 104, 105, 106, 107",  query);
         
         query = store.Query<Position, Rotation>().AllComponents(all).AnyComponents(any);
-        AssertResult("2, 7, 8, 9, 10",  query);
+        AssertResult("11, 102, 103, 104, 105, 106, 107",  query);
     
         query = store.Query<Position, Rotation, EntityName>().AllComponents(all).AnyComponents(any);
-        AssertResult("2, 7, 8, 9, 10",  query);
+        AssertResult("11, 102, 103, 104, 105, 106, 107",  query);
 
         query = store.Query<Position, Rotation, EntityName, Scale3>().AllComponents(all).AnyComponents(any);
-        AssertResult("2, 7, 8, 9, 10",  query);
+        AssertResult("11, 102, 103, 104, 105, 106, 107",  query);
         
         query = store.Query<Position, Rotation, EntityName, Scale3, MyComponent1>().AllComponents(all).AnyComponents(any);
-        AssertResult("2, 7, 8, 9, 10",  query);
+        AssertResult("11, 102, 103, 104, 105, 106, 107",  query);
     }
     
     [Test]
@@ -245,19 +283,19 @@ public static void Test_QueryComponents_overloads_WithoutAllComponents_WithoutAn
         var any = ComponentTypes.Get<Comp1>();
         
         var query = store.Query().WithoutAllComponents(all).WithoutAnyComponents(any);
-        AssertResult("1, 3, 4, 5, 6",  query);
+        AssertResult("1, 12, 13, 14, 15, 16, 17",  query);
         
         query = store.Query<Position, Rotation>().WithoutAllComponents(all).WithoutAnyComponents(any);
-        AssertResult("1, 3, 4, 5, 6",  query);
+        AssertResult("1, 12, 13, 14, 15, 16, 17",  query);
     
         query = store.Query<Position, Rotation, EntityName>().WithoutAllComponents(all).WithoutAnyComponents(any);
-        AssertResult("1, 3, 4, 5, 6",  query);
+        AssertResult("1, 12, 13, 14, 15, 16, 17",  query);
 
         query = store.Query<Position, Rotation, EntityName, Scale3>().WithoutAllComponents(all).WithoutAnyComponents(any);
-        AssertResult("1, 3, 4, 5, 6",  query);
+        AssertResult("1, 12, 13, 14, 15, 16, 17",  query);
         
         query = store.Query<Position, Rotation, EntityName, Scale3, MyComponent1>().WithoutAllComponents(all).WithoutAnyComponents(any);
-        AssertResult("1, 3, 4, 5, 6",  query);
+        AssertResult("1, 12, 13, 14, 15, 16, 17",  query);
     }
     
     [Test]
diff --git a/src/Tests/ECS/Arch/Test_QueryJobArg.cs b/src/Tests/ECS/Arch/Test_QueryJobArg.cs
index 8575cdce2..25727e705 100644
--- a/src/Tests/ECS/Arch/Test_QueryJobArg.cs
+++ b/src/Tests/ECS/Arch/Test_QueryJobArg.cs
@@ -313,6 +313,145 @@ public static void Test_QueryJobArg_RunParallel_Arg_5()
             entities[n] = archetype.CreateEntity();
         }
     }
+    
+    [Test]
+    public static void Test_QueryJobArg_RunParallel_Arg_6()
+    {
+        var store       = CreateTestStore();
+        var archetype   = store.GetArchetype(ComponentTypes.Get<MyComponent1, MyComponent2, MyComponent3, Position, Rotation, Scale3>());
+        var entities    = new Entity[EntityCount];
+
+        var query       = store.Query<MyComponent1, MyComponent2, MyComponent3, Position, Rotation, Scale3>();
+        var count       = 0;
+        var forEach = query.ForEach((myComponent1, myComponent2, myComponent3, position, rotation, scale3, chunkEntities) => {
+            AssertExecution(chunkEntities);
+            var span1 = myComponent1.Span;
+            var span2 = myComponent2.Span;
+            var span3 = myComponent3.Span;
+            var span4 = position.Span;
+            var span5 = rotation.Span;
+            var span6 = scale3.Span;
+            var ids = chunkEntities.Ids;
+            Interlocked.Add(ref count, span1.Length);
+            for (int n = 0; n < span1.Length; n++) {
+                Mem.AreEqual(span1[n].a + 1, ids[n]);
+                ++span1[n].a;
+                ++span2[n].b;
+                ++span3[n].b;
+                ++span4[n].x;
+                ++span5[n].x;
+                ++span6[n].x;
+            }
+        });
+        Assert.AreEqual(16, forEach.ParallelComponentMultiple);
+        forEach.MinParallelChunkLength = 1;
+        
+        for (int n = 0; n < EntityCount; n++)
+        {
+            for (int i = 0; i < n; i++) {
+                var entity = entities[i];
+                entity.GetComponent<MyComponent1>().a = i;
+                entity.GetComponent<MyComponent2>().b = i;
+                entity.GetComponent<MyComponent3>().b = i;
+                entity.GetComponent<Position>().x     = i;
+                entity.GetComponent<Rotation>().x     = i;
+                entity.GetComponent<Scale3>().x         = i;
+            }
+            // method under test
+            count = 0;
+            Run(forEach, n);
+            
+            Mem.AreEqual(n, count);
+            for (int i = 0; i < n; i++) {
+                var entity = entities[i];
+                var comp1 = entity.GetComponent<MyComponent1>();
+                Mem.AreEqual(i + 1, comp1.a);
+                var comp2 = entity.GetComponent<MyComponent2>();
+                Mem.AreEqual(i + 1, comp2.b);
+                var comp3 = entity.GetComponent<MyComponent3>();
+                Mem.AreEqual(i + 1, comp3.b);
+                var comp4 = entity.GetComponent<Position>();
+                Mem.AreEqual(i + 1, comp4.x);
+                var comp5 = entity.GetComponent<Rotation>();
+                Mem.AreEqual(i + 1, comp5.x);
+                var comp6 = entity.GetComponent<Scale3>();
+                Mem.AreEqual(i + 1, comp6.x);
+            }
+            entities[n] = archetype.CreateEntity();
+        }
+    }
+    
+    [Test]
+    public static void Test_QueryJobArg_RunParallel_Arg_7()
+    {
+        var store       = CreateTestStore();
+        var archetype   = store.GetArchetype(ComponentTypes.Get<MyComponent1, MyComponent2, MyComponent3, MyComponent4, Position, Rotation, Scale3>());
+        var entities    = new Entity[EntityCount];
+
+        var query       = store.Query<MyComponent1, MyComponent2, MyComponent3, MyComponent4, Position, Rotation, Scale3>();
+        var count       = 0;
+        var forEach = query.ForEach((myComponent1, myComponent2, myComponent3, myComponent4, position, rotation, scale3, chunkEntities) => {
+            AssertExecution(chunkEntities);
+            var span1 = myComponent1.Span;
+            var span2 = myComponent2.Span;
+            var span3 = myComponent3.Span;
+            var span4 = myComponent4.Span;
+            var span5 = position.Span;
+            var span6 = rotation.Span;
+            var span7 = scale3.Span;
+            var ids = chunkEntities.Ids;
+            Interlocked.Add(ref count, span1.Length);
+            for (int n = 0; n < span1.Length; n++) {
+                Mem.AreEqual(span1[n].a + 1, ids[n]);
+                ++span1[n].a;
+                ++span2[n].b;
+                ++span3[n].b;
+                ++span4[n].b;
+                ++span5[n].x;
+                ++span6[n].x;
+                ++span7[n].x;
+            }
+        });
+        Assert.AreEqual(16, forEach.ParallelComponentMultiple);
+        forEach.MinParallelChunkLength = 1;
+        
+        for (int n = 0; n < EntityCount; n++)
+        {
+            for (int i = 0; i < n; i++) {
+                var entity = entities[i];
+                entity.GetComponent<MyComponent1>().a = i;
+                entity.GetComponent<MyComponent2>().b = i;
+                entity.GetComponent<MyComponent3>().b = i;
+                entity.GetComponent<MyComponent4>().b = i;
+                entity.GetComponent<Position>().x     = i;
+                entity.GetComponent<Rotation>().x     = i;
+                entity.GetComponent<Scale3>().x         = i;
+            }
+            // method under test
+            count = 0;
+            Run(forEach, n);
+            
+            Mem.AreEqual(n, count);
+            for (int i = 0; i < n; i++) {
+                var entity = entities[i];
+                var comp1 = entity.GetComponent<MyComponent1>();
+                Mem.AreEqual(i + 1, comp1.a);
+                var comp2 = entity.GetComponent<MyComponent2>();
+                Mem.AreEqual(i + 1, comp2.b);
+                var comp3 = entity.GetComponent<MyComponent3>();
+                Mem.AreEqual(i + 1, comp3.b);
+                var comp4 = entity.GetComponent<MyComponent4>();
+                Mem.AreEqual(i + 1, comp4.b);
+                var comp5 = entity.GetComponent<Position>();
+                Mem.AreEqual(i + 1, comp5.x);
+                var comp6 = entity.GetComponent<Rotation>();
+                Mem.AreEqual(i + 1, comp6.x);
+                var comp7 = entity.GetComponent<Scale3>();
+                Mem.AreEqual(i + 1, comp7.x);
+            }
+            entities[n] = archetype.CreateEntity();
+        }
+    }
 
 }
 
diff --git a/src/Tests/ECS/Arch/Test_Signature.cs b/src/Tests/ECS/Arch/Test_Signature.cs
index 81d9c7a2b..2aa5e4588 100644
--- a/src/Tests/ECS/Arch/Test_Signature.cs
+++ b/src/Tests/ECS/Arch/Test_Signature.cs
@@ -42,6 +42,12 @@ public static void Test_Signature_Get()
         
         var sig5_ =     Signature.Get<Rotation, Position, Scale3, EntityName, MyComponent1>();
         AreEqual("Signature: [Rotation, Position, Scale3, EntityName, MyComponent1]", sig5_.ToString());
+        
+        var sig6_ =     Signature.Get<Rotation, Position, Scale3, EntityName, MyComponent1, MyComponent2>();
+        AreEqual("Signature: [Rotation, Position, Scale3, EntityName, MyComponent1, MyComponent2]", sig6_.ToString());
+        
+        var sig7_ =     Signature.Get<Rotation, Position, Scale3, EntityName, MyComponent1, MyComponent2, MyComponent3>();
+        AreEqual("Signature: [Rotation, Position, Scale3, EntityName, MyComponent1, MyComponent2, MyComponent3]", sig7_.ToString());
     }
     
     [Test]
@@ -51,18 +57,24 @@ public static void Test_Signature_GetComponentTypes() {
         var ct3 = ComponentTypes.Get<Position, Rotation, Scale3>()                          .ToString();
         var ct4 = ComponentTypes.Get<Position, Rotation, Scale3, EntityName>()              .ToString();
         var ct5 = ComponentTypes.Get<Position, Rotation, Scale3, EntityName, MyComponent1>().ToString();
+        var ct6 = ComponentTypes.Get<Position, Rotation, Scale3, EntityName, MyComponent1, MyComponent2>().ToString();
+        var ct7 = ComponentTypes.Get<Position, Rotation, Scale3, EntityName, MyComponent1, MyComponent2, MyComponent3>().ToString();
         
         var s1 = Signature.Get<Position>();
         var s2 = Signature.Get<Position, Rotation>();
         var s3 = Signature.Get<Position, Rotation, Scale3>();
         var s4 = Signature.Get<Position, Rotation, Scale3, EntityName>();
         var s5 = Signature.Get<Position, Rotation, Scale3, EntityName, MyComponent1>();
+        var s6 = Signature.Get<Position, Rotation, Scale3, EntityName, MyComponent1, MyComponent2>();
+        var s7 = Signature.Get<Position, Rotation, Scale3, EntityName, MyComponent1, MyComponent2, MyComponent3>();
         
         AreEqual(s1.ComponentTypes.ToString(), ct1);
         AreEqual(s2.ComponentTypes.ToString(), ct2);
         AreEqual(s3.ComponentTypes.ToString(), ct3);
         AreEqual(s4.ComponentTypes.ToString(), ct4);
         AreEqual(s5.ComponentTypes.ToString(), ct5);
+        AreEqual(s6.ComponentTypes.ToString(), ct6);
+        AreEqual(s7.ComponentTypes.ToString(), ct7);
     }
 }
 
diff --git a/src/Tests/ECS/Base/Test_ComponentSchema.cs b/src/Tests/ECS/Base/Test_ComponentSchema.cs
index c69e511ae..3be6ce64c 100644
--- a/src/Tests/ECS/Base/Test_ComponentSchema.cs
+++ b/src/Tests/ECS/Base/Test_ComponentSchema.cs
@@ -49,12 +49,12 @@ public static void Test_ComponentTypes()
         var components  = schema.Components;
         var scripts     = schema.Scripts;
         
-        AreEqual("components: 74  scripts: 10  entity tags: 16", schema.ToString());
-        AreEqual(75,    components.Length);
+        AreEqual("components: 76  scripts: 10  entity tags: 16", schema.ToString());
+        AreEqual(77,    components.Length);
         AreEqual(11,    scripts.Length);
         
-        AreEqual(80,    schema.SchemaTypeByKey.Count);
-        AreEqual(74,    schema.ComponentTypeByType.Count);
+        AreEqual(82,    schema.SchemaTypeByKey.Count);
+        AreEqual(76,    schema.ComponentTypeByType.Count);
         AreEqual(10,    schema.ScriptTypeByType.Count);
         
         IsNull(components[0]);
diff --git a/src/Tests/ECS/Entity/Test_StructComponent.cs b/src/Tests/ECS/Entity/Test_StructComponent.cs
index 327901edc..b9958e33f 100644
--- a/src/Tests/ECS/Entity/Test_StructComponent.cs
+++ b/src/Tests/ECS/Entity/Test_StructComponent.cs
@@ -133,20 +133,28 @@ public static void Test_4_GetArchetype() {
         var type1   = store.GetArchetype(ComponentTypes.Get<Position, Rotation>());
         var type2   = store.GetArchetype(ComponentTypes.Get<Rotation, Position>());
         AreSame(type1, type2);
+        AreEqual(2, store.Archetypes.Length);
         
         type1   = store.GetArchetype(ComponentTypes.Get<Position, Rotation, MyComponent1>());
         type2   = store.GetArchetype(ComponentTypes.Get<MyComponent1, Position, Rotation>());
         AreSame(type1, type2);
+        AreEqual(3, store.Archetypes.Length);
         
         type1       = store.GetArchetype(ComponentTypes.Get<Position, Rotation, MyComponent1, MyComponent2>());
         type2       = store.GetArchetype(ComponentTypes.Get<MyComponent1, Position, Rotation,  MyComponent2>());
         AreSame(type1, type2);
+        AreEqual(4, store.Archetypes.Length);
         
         type1       = store.GetArchetype(ComponentTypes.Get<Position, Rotation, MyComponent1, Scale3, MyComponent2>());
         type2       = store.GetArchetype(ComponentTypes.Get<Scale3, MyComponent1, Position, Rotation, MyComponent2>());
         AreSame(type1, type2);
-        
         AreEqual(5, store.Archetypes.Length);
+        
+        type1       = store.GetArchetype(ComponentTypes.Get<Position, Rotation, MyComponent1, Scale3, MyComponent2, MyComponent4>());
+        type2       = store.GetArchetype(ComponentTypes.Get<Scale3, MyComponent4, MyComponent1, Position, Rotation, MyComponent2>());
+        AreSame(type1, type2);
+        
+        AreEqual(6, store.Archetypes.Length);
         AreEqual(0, type1.Count);
         AreEqual(0, type2.Count);
     }
diff --git a/src/Tests/ECS/Index/Query/Arg5.cs b/src/Tests/ECS/Index/Query/Arg5.cs
index 4596689f9..007e99640 100644
--- a/src/Tests/ECS/Index/Query/Arg5.cs
+++ b/src/Tests/ECS/Index/Query/Arg5.cs
@@ -15,11 +15,15 @@ private static void QueryArg5 (IndexContext cx)
                                                                               HasValue<IndexedInt,    int>   (123);
         var query4  = store.Query<Position, Rotation, MyComponent1, MyComponent2, MyComponent3>().        HasValue<AttackComponent, Entity>(cx.target);
         var query5  = store.Query<Position, Rotation, MyComponent1, MyComponent2, MyComponent3>().        ValueInRange<IndexedInt, int>(100, 1000);
+       
+        
+        
         cx.query1 = query1;
         cx.query2 = query2;
         cx.query3 = query3;
         cx.query4 = query4;
         cx.query5 = query5;
+        
         {
             int count = 0;
             query1.ForEachEntity((ref Position pos, ref Rotation _, ref MyComponent1 _, ref MyComponent2 _, ref MyComponent3 _, Entity entity) => {
@@ -82,7 +86,7 @@ private static void QueryArg5 (IndexContext cx)
                 }
             }
             AreEqual(3, count);
-        }
+        } 
     }
 }
 
diff --git a/src/Tests/ECS/Index/Query/Arg6.cs b/src/Tests/ECS/Index/Query/Arg6.cs
new file mode 100644
index 000000000..5b491423b
--- /dev/null
+++ b/src/Tests/ECS/Index/Query/Arg6.cs
@@ -0,0 +1,93 @@
+using Friflo.Engine.ECS;
+using static NUnit.Framework.Assert;
+
+// ReSharper disable InconsistentNaming
+namespace Tests.ECS.Index.Query {
+
+public static partial class Test_Index_Query
+{
+    private static void QueryArg6 (IndexContext cx)
+    {
+        var store = cx.store;
+        var query1  = store.Query<Position, Rotation, MyComponent1, MyComponent2, MyComponent3, MyComponent4>().        HasValue<IndexedName,   string>("find-me");
+        var query2  = store.Query<Position, Rotation, MyComponent1, MyComponent2, MyComponent3, MyComponent4>().        HasValue<IndexedInt,    int>   (123);
+        var query3  = store.Query<Position, Rotation, MyComponent1, MyComponent2, MyComponent3, MyComponent4>().        HasValue<IndexedName,   string>("find-me").
+                                                                              HasValue<IndexedInt,    int>   (123);
+        var query4  = store.Query<Position, Rotation, MyComponent1, MyComponent2, MyComponent3, MyComponent4>().        HasValue<AttackComponent, Entity>(cx.target);
+        var query5  = store.Query<Position, Rotation, MyComponent1, MyComponent2, MyComponent3, MyComponent4>().        ValueInRange<IndexedInt, int>(100, 1000);
+       
+        
+        
+        cx.query1 = query1;
+        cx.query2 = query2;
+        cx.query3 = query3;
+        cx.query4 = query4;
+        cx.query5 = query5;
+        
+        {
+            int count = 0;
+            query1.ForEachEntity((ref Position pos, ref Rotation _, ref MyComponent1 _, ref MyComponent2 _, ref MyComponent3 _, ref MyComponent4 _, Entity entity) => {
+                switch (count++) {
+                    case 0: AreEqual(11, entity.Id); AreEqual(11f, pos.x); break;
+                    case 1: AreEqual(13, entity.Id); AreEqual(13f, pos.x); break;
+                }
+                AreEqual("find-me", entity.GetComponent<IndexedName>().name);
+            });
+            AreEqual(2, count);
+        } { 
+            int count = 0;
+            query2.ForEachEntity((ref Position pos, ref Rotation _, ref MyComponent1 _, ref MyComponent2 _, ref MyComponent3 _, ref MyComponent4 _, Entity entity) => {
+                switch (count++) {
+                    case 0: AreEqual(12, entity.Id); AreEqual(12f, pos.x); break;
+                    case 1: AreEqual(13, entity.Id); AreEqual(13f, pos.x); break;
+                }
+                AreEqual(123, entity.GetComponent<IndexedInt>().value);
+            });
+            AreEqual(2, count);
+        } { 
+            var count = 0;
+            query3.ForEachEntity((ref Position pos, ref Rotation _, ref MyComponent1 _, ref MyComponent2 _, ref MyComponent3 _, ref MyComponent4 _, Entity entity) => {
+                switch (count++) {
+                    case 0: AreEqual(11, entity.Id); AreEqual(11f, pos.x); break;
+                    case 1: AreEqual(13, entity.Id); AreEqual(13f, pos.x); break;
+                    case 2: AreEqual(12, entity.Id); AreEqual(12f, pos.x); break;
+                }
+            });
+            AreEqual(3, count);
+        } {
+            var count = 0;
+            query4.ForEachEntity((ref Position pos, ref Rotation _, ref MyComponent1 _, ref MyComponent2 _, ref MyComponent3 _, ref MyComponent4 _, Entity entity) => {
+                count++;
+                AreEqual(13,        entity.Id);     AreEqual(13f, pos.x);
+                AreEqual(cx.target, entity.GetComponent<AttackComponent>().target);
+            });
+            AreEqual(1, count);
+        } {
+            var count = 0;
+            query5.ForEachEntity((ref Position pos, ref Rotation _, ref MyComponent1 _, ref MyComponent2 _, ref MyComponent3 _, ref MyComponent4 _, Entity entity) => {
+                switch (count++) {
+                    case 0: AreEqual(12, entity.Id); AreEqual(12f, pos.x); break;
+                    case 1: AreEqual(13, entity.Id); AreEqual(13f, pos.x); break;
+                    case 2: AreEqual(14, entity.Id); AreEqual(14f, pos.x); break;
+                }
+            });
+            AreEqual(3, count);
+        } {
+            var count = 0;
+            foreach (var (positions, _, _, _, _, _, entities) in query5.Chunks) {
+                AreEqual(1, positions.Length);
+                AreEqual(1, entities.Length);
+                var pos = positions[0]; // positions.start can be > 0
+                var id  = entities [0]; // entities.start  can be > 0
+                switch (count++) {
+                    case 0: AreEqual(12, id); AreEqual(12f, pos.x); break;
+                    case 1: AreEqual(13, id); AreEqual(13f, pos.x); break;
+                    case 2: AreEqual(14, id); AreEqual(14f, pos.x); break;
+                }
+            }
+            AreEqual(3, count);
+        } 
+    }
+}
+
+}
diff --git a/src/Tests/ECS/Index/Query/Arg7.cs b/src/Tests/ECS/Index/Query/Arg7.cs
new file mode 100644
index 000000000..fb71fb4cc
--- /dev/null
+++ b/src/Tests/ECS/Index/Query/Arg7.cs
@@ -0,0 +1,93 @@
+using Friflo.Engine.ECS;
+using static NUnit.Framework.Assert;
+
+// ReSharper disable InconsistentNaming
+namespace Tests.ECS.Index.Query {
+
+public static partial class Test_Index_Query
+{
+    private static void QueryArg7 (IndexContext cx)
+    {
+        var store = cx.store;
+        var query1  = store.Query<Position, Rotation, MyComponent1, MyComponent2, MyComponent3, MyComponent4, MyComponent5>().        HasValue<IndexedName,   string>("find-me");
+        var query2  = store.Query<Position, Rotation, MyComponent1, MyComponent2, MyComponent3, MyComponent4, MyComponent5>().        HasValue<IndexedInt,    int>   (123);
+        var query3  = store.Query<Position, Rotation, MyComponent1, MyComponent2, MyComponent3, MyComponent4, MyComponent5>().        HasValue<IndexedName,   string>("find-me").
+                                                                              HasValue<IndexedInt,    int>   (123);
+        var query4  = store.Query<Position, Rotation, MyComponent1, MyComponent2, MyComponent3, MyComponent4, MyComponent5>().        HasValue<AttackComponent, Entity>(cx.target);
+        var query5  = store.Query<Position, Rotation, MyComponent1, MyComponent2, MyComponent3, MyComponent4, MyComponent5>().        ValueInRange<IndexedInt, int>(100, 1000);
+       
+        
+        
+        cx.query1 = query1;
+        cx.query2 = query2;
+        cx.query3 = query3;
+        cx.query4 = query4;
+        cx.query5 = query5;
+        
+        {
+            int count = 0;
+            query1.ForEachEntity((ref Position pos, ref Rotation _, ref MyComponent1 _, ref MyComponent2 _, ref MyComponent3 _, ref MyComponent4 _, ref MyComponent5 _, Entity entity) => {
+                switch (count++) {
+                    case 0: AreEqual(11, entity.Id); AreEqual(11f, pos.x); break;
+                    case 1: AreEqual(13, entity.Id); AreEqual(13f, pos.x); break;
+                }
+                AreEqual("find-me", entity.GetComponent<IndexedName>().name);
+            });
+            AreEqual(2, count);
+        } { 
+            int count = 0;
+            query2.ForEachEntity((ref Position pos, ref Rotation _, ref MyComponent1 _, ref MyComponent2 _, ref MyComponent3 _, ref MyComponent4 _, ref MyComponent5 _, Entity entity) => {
+                switch (count++) {
+                    case 0: AreEqual(12, entity.Id); AreEqual(12f, pos.x); break;
+                    case 1: AreEqual(13, entity.Id); AreEqual(13f, pos.x); break;
+                }
+                AreEqual(123, entity.GetComponent<IndexedInt>().value);
+            });
+            AreEqual(2, count);
+        } { 
+            var count = 0;
+            query3.ForEachEntity((ref Position pos, ref Rotation _, ref MyComponent1 _, ref MyComponent2 _, ref MyComponent3 _, ref MyComponent4 _, ref MyComponent5 _, Entity entity) => {
+                switch (count++) {
+                    case 0: AreEqual(11, entity.Id); AreEqual(11f, pos.x); break;
+                    case 1: AreEqual(13, entity.Id); AreEqual(13f, pos.x); break;
+                    case 2: AreEqual(12, entity.Id); AreEqual(12f, pos.x); break;
+                }
+            });
+            AreEqual(3, count);
+        } {
+            var count = 0;
+            query4.ForEachEntity((ref Position pos, ref Rotation _, ref MyComponent1 _, ref MyComponent2 _, ref MyComponent3 _, ref MyComponent4 _, ref MyComponent5 _, Entity entity) => {
+                count++;
+                AreEqual(13,        entity.Id);     AreEqual(13f, pos.x);
+                AreEqual(cx.target, entity.GetComponent<AttackComponent>().target);
+            });
+            AreEqual(1, count);
+        } {
+            var count = 0;
+            query5.ForEachEntity((ref Position pos, ref Rotation _, ref MyComponent1 _, ref MyComponent2 _, ref MyComponent3 _, ref MyComponent4 _, ref MyComponent5 _, Entity entity) => {
+                switch (count++) {
+                    case 0: AreEqual(12, entity.Id); AreEqual(12f, pos.x); break;
+                    case 1: AreEqual(13, entity.Id); AreEqual(13f, pos.x); break;
+                    case 2: AreEqual(14, entity.Id); AreEqual(14f, pos.x); break;
+                }
+            });
+            AreEqual(3, count);
+        } {
+            var count = 0;
+            foreach (var (positions, _, _, _, _, _, _, entities) in query5.Chunks) {
+                AreEqual(1, positions.Length);
+                AreEqual(1, entities.Length);
+                var pos = positions[0]; // positions.start can be > 0
+                var id  = entities [0]; // entities.start  can be > 0
+                switch (count++) {
+                    case 0: AreEqual(12, id); AreEqual(12f, pos.x); break;
+                    case 1: AreEqual(13, id); AreEqual(13f, pos.x); break;
+                    case 2: AreEqual(14, id); AreEqual(14f, pos.x); break;
+                }
+            }
+            AreEqual(3, count);
+        } 
+    }
+}
+
+}
diff --git a/src/Tests/ECS/Index/Query/Test_Index_Query.cs b/src/Tests/ECS/Index/Query/Test_Index_Query.cs
index 4562dc042..4e2d974c0 100644
--- a/src/Tests/ECS/Index/Query/Test_Index_Query.cs
+++ b/src/Tests/ECS/Index/Query/Test_Index_Query.cs
@@ -44,7 +44,9 @@ private static IndexContext Query_Setup()
                 new Rotation(),
                 new MyComponent1 { a = n },
                 new MyComponent2 { b = n },
-                new MyComponent3 { b = n });
+                new MyComponent3 { b = n },
+                new MyComponent4 { b = n },
+                new MyComponent5 { b = n });
             entities.Add(entity);
         }
         cx.target   = targets[0];
@@ -149,6 +151,22 @@ public static void Test_Index_Component_Add_Remove_Arg5()
         QueryArg5(cx);
         Query_Assertions(cx);
     }
+    
+    [Test]
+    public static void Test_Index_Component_Add_Remove_Arg6()
+    {
+        var cx = Query_Setup();
+        QueryArg6(cx);
+        Query_Assertions(cx);
+    }
+    
+    [Test]
+    public static void Test_Index_Component_Add_Remove_Arg7()
+    {
+        var cx = Query_Setup();
+        QueryArg7(cx);
+        Query_Assertions(cx);
+    }
 }
 
 }
diff --git a/src/Tests/ECS/Systems/Test_Query.cs b/src/Tests/ECS/Systems/Test_Query.cs
index 2584a3b77..30942d55a 100644
--- a/src/Tests/ECS/Systems/Test_Query.cs
+++ b/src/Tests/ECS/Systems/Test_Query.cs
@@ -29,7 +29,7 @@ public static void Test_Query_arg_count_1()
         foreach (var chunk in query.Chunks) {
             if (chunkCount++ == 1) {
                 Mem.AreEqual(1, chunk.Length);
-                Mem.AreEqual("Chunks[1]    Archetype: [EntityName, Position, Rotation, Scale3, Transform, TreeNode, MyComponent1]  entities: 1", chunk.ToString());
+                Mem.AreEqual("Chunks[1]    Archetype: [EntityName, Position, Rotation, Scale3, Transform, TreeNode, MyComponent1, MyComponent2]  entities: 1", chunk.ToString());
                 var positions = chunk.Chunk1;
                 Mem.AreEqual("Position[1]", positions.ToString());
                 Mem.AreEqual(1, positions[0].x);
@@ -71,7 +71,7 @@ public static void Test_Query_arg_count_2()
         foreach (var chunk in query.Chunks) {
             if (chunkCount++ == 1) {
                 Mem.AreEqual(1, chunk.Length);
-                Mem.AreEqual("Chunks[1]    Archetype: [EntityName, Position, Rotation, Scale3, Transform, TreeNode, MyComponent1]  entities: 1", chunk.ToString());
+                Mem.AreEqual("Chunks[1]    Archetype: [EntityName, Position, Rotation, Scale3, Transform, TreeNode, MyComponent1, MyComponent2]  entities: 1", chunk.ToString());
             }
         }
         Mem.AreEqual(2, chunkCount);
@@ -141,7 +141,7 @@ public static void Test_Query_arg_count_4()
         foreach (var chunk in query.Chunks) {
             if (chunkCount++ == 1) {
                 Mem.AreEqual(1, chunk.Length);
-                Mem.AreEqual("Chunks[1]    Archetype: [EntityName, Position, Rotation, Scale3, Transform, TreeNode, MyComponent1]  entities: 1", chunk.ToString());
+                Mem.AreEqual("Chunks[1]    Archetype: [EntityName, Position, Rotation, Scale3, Transform, TreeNode, MyComponent1, MyComponent2]  entities: 1", chunk.ToString());
             }
         }
         Mem.AreEqual(2, chunkCount);
@@ -177,11 +177,10 @@ public static void Test_Query_arg_count_5()
         foreach (var chunk in query.Chunks) {
             if (chunkCount++ == 0) {
                 Mem.AreEqual(1, chunk.Length);
-                Mem.AreEqual("Chunks[1]    Archetype: [EntityName, Position, Rotation, Scale3, Transform, TreeNode, MyComponent1]  entities: 1", chunk.ToString());
+                Mem.AreEqual("Chunks[1]    Archetype: [EntityName, Position, Rotation, Scale3, Transform, TreeNode, MyComponent1, MyComponent2]  entities: 1", chunk.ToString());
             }
         }
         Mem.AreEqual(1, chunkCount);
-        AssertChunkExtensions(query);
         
         // --- run perf
         var start = Mem.GetAllocatedBytes();
@@ -192,7 +191,80 @@ public static void Test_Query_arg_count_5()
         Mem.AssertNoAlloc(start);
     }
     
-    private static void AssertChunkExtensions(ArchetypeQuery<Position, Rotation, Scale3, Transform, EntityName> query) {
+    [Test]
+    public static void Test_Query_arg_count_6()
+    {
+        var store = SetupTestStore();
+        var root  = store.StoreRoot;
+        root.AddScript(new SystemSet { argCount = 6 });
+        
+        var archetype   = store.GetArchetype(ComponentTypes.Get<Position, Rotation, Scale3, EntityName>());
+        for (int n = 2; n <= 1000; n++) {
+            var child = archetype.CreateEntity();
+            child.Position      = new Position(n, 0, 0);
+            child.Rotation      = new Rotation(n, 0, 0, 0);
+            child.Scale3        = new Scale3  (n, 0, 0);
+            child.Name.value    = "child";
+            root.AddChild(child);
+        }
+        // --- force one time allocations
+        var  query = store.Query<Position, Rotation, Scale3, Transform, EntityName, MyComponent1>();
+        int chunkCount = 0;
+        foreach (var chunk in query.Chunks) {
+            if (chunkCount++ == 0) {
+                Mem.AreEqual(1, chunk.Length);
+                Mem.AreEqual("Chunks[1]    Archetype: [EntityName, Position, Rotation, Scale3, Transform, TreeNode, MyComponent1, MyComponent2]  entities: 1", chunk.ToString());
+            }
+        }
+        Mem.AreEqual(1, chunkCount);
+        
+        // --- run perf
+        var start = Mem.GetAllocatedBytes();
+        // 10_000_000 ~ #PC: 1078 ms
+        for (long n = 0; n < Count; n++) {
+            foreach (var (_, _, _, _, _, _, _) in query.Chunks) { }
+        }
+        Mem.AssertNoAlloc(start);
+    }
+    
+    [Test]
+    public static void Test_Query_arg_count_7()
+    {
+        var store = SetupTestStore();
+        var root  = store.StoreRoot;
+        root.AddScript(new SystemSet { argCount = 6 });
+        
+        var archetype   = store.GetArchetype(ComponentTypes.Get<Position, Rotation, Scale3, EntityName>());
+        for (int n = 2; n <= 1000; n++) {
+            var child = archetype.CreateEntity();
+            child.Position      = new Position(n, 0, 0);
+            child.Rotation      = new Rotation(n, 0, 0, 0);
+            child.Scale3        = new Scale3  (n, 0, 0);
+            child.Name.value    = "child";
+            root.AddChild(child);
+        }
+        // --- force one time allocations
+        var  query = store.Query<Position, Rotation, Scale3, Transform, EntityName, MyComponent1, MyComponent2>();
+        int chunkCount = 0;
+        foreach (var chunk in query.Chunks) {
+            if (chunkCount++ == 0) {
+                Mem.AreEqual(1, chunk.Length);
+                Mem.AreEqual("Chunks[1]    Archetype: [EntityName, Position, Rotation, Scale3, Transform, TreeNode, MyComponent1, MyComponent2]  entities: 1", chunk.ToString());
+            }
+        }
+        Mem.AreEqual(1, chunkCount);
+        AssertChunkExtensions(query);
+        
+        // --- run perf
+        var start = Mem.GetAllocatedBytes();
+        // 10_000_000 ~ #PC: 1078 ms
+        for (long n = 0; n < Count; n++) {
+            foreach (var (_, _, _, _, _, _, _, _) in query.Chunks) { }
+        }
+        Mem.AssertNoAlloc(start);
+    }
+    
+    private static void AssertChunkExtensions(ArchetypeQuery<Position, Rotation, Scale3, Transform, EntityName, MyComponent1, MyComponent2> query) {
 
         foreach (var chunk in query.Chunks) {
             var length = chunk.Entities.Length;
@@ -221,6 +293,7 @@ private static EntityStore SetupTestStore() {
         root.AddComponent<Transform>();
         root.AddComponent<Scale3>();
         root.AddComponent<MyComponent1>();
+        root.AddComponent<MyComponent2>();
         store.SetStoreRoot(root);
         return store;
     }
diff --git a/src/Tests/ECS/Systems/Test_ScriptSystems.cs b/src/Tests/ECS/Systems/Test_ScriptSystems.cs
index e7bb5dae0..5a309245b 100644
--- a/src/Tests/ECS/Systems/Test_ScriptSystems.cs
+++ b/src/Tests/ECS/Systems/Test_ScriptSystems.cs
@@ -22,6 +22,8 @@ public override void Start() {
             3 => new MySystem_Arg3(),
             4 => new MySystem_Arg4(),
             5 => new MySystem_Arg5(),
+            6 => new MySystem_Arg6(),
+            7 => new MySystem_Arg7(),
             _ => throw new ArgumentException($"value: {argCount}", nameof(argCount))
         };
         Systems.Add(system);
@@ -181,6 +183,67 @@ protected override void OnUpdate()
     }
 }
 
+public class MySystem_Arg6 : QuerySystem<Position, Rotation, EntityName, Scale3, Transform, MyComponent1>
+{
+    /// <summary> Cover <see cref="ChunkEnumerator{T1}.MoveNext"/> </summary>
+    protected override void OnUpdate()
+    {
+        var store       = Query.Store;
+        var childArch   = store.GetArchetype(ComponentTypes.Get<Position, Rotation, EntityName, Scale3, Transform, MyComponent1>());
+        int chunkCount  = 0;
+        foreach (var (positions, rotation, name, scale, transform, myComponent1, entities) in Query.Chunks) {
+            var matrix4X4   = transform.AsSpanMatrix4x4();
+            var length      = entities.Length;
+            Mem.AreEqual(length,                    matrix4X4.Length);
+            Mem.AreEqual(length,                    positions.Length);
+            Mem.AreEqual(length,                    rotation.Length);
+            Mem.AreEqual(length,                    name.Length);
+            Mem.AreEqual(length,                    scale.Length);
+            Mem.AreEqual(length,                    transform.Length);
+            Mem.AreEqual(length,                    myComponent1.Length);
+            Mem.AreEqual(positions[0].x,            entities.Ids[0]);
+            Mem.AreEqual(positions[length - 1].x,   entities.Ids[length - 1]);
+            switch(chunkCount++) {
+                case 0:     Mem.AreEqual(999,   length);    Mem.AreSame(childArch,                  entities.Archetype); break;
+                case 1:     Mem.AreEqual(1,     length);    Mem.AreSame(store.StoreRoot.Archetype,  entities.Archetype); break;
+                default:    throw new InvalidOperationException("unexpected");
+            }
+        }
+        Mem.AreEqual(2, chunkCount);
+    }
+}
+
+public class MySystem_Arg7 : QuerySystem<Position, Rotation, EntityName, Scale3, Transform, MyComponent1, MyComponent2>
+{
+    /// <summary> Cover <see cref="ChunkEnumerator{T1}.MoveNext"/> </summary>
+    protected override void OnUpdate()
+    {
+        var store       = Query.Store;
+        var childArch   = store.GetArchetype(ComponentTypes.Get<Position, Rotation, EntityName, Scale3, Transform, MyComponent1, MyComponent2>());
+        int chunkCount  = 0;
+        foreach (var (positions, rotation, name, scale, transform, myComponent1,myComponent2, entities) in Query.Chunks) {
+            var matrix4X4   = transform.AsSpanMatrix4x4();
+            var length      = entities.Length;
+            Mem.AreEqual(length,                    matrix4X4.Length);
+            Mem.AreEqual(length,                    positions.Length);
+            Mem.AreEqual(length,                    rotation.Length);
+            Mem.AreEqual(length,                    name.Length);
+            Mem.AreEqual(length,                    scale.Length);
+            Mem.AreEqual(length,                    transform.Length);
+            Mem.AreEqual(length,                    myComponent1.Length);
+            Mem.AreEqual(length,                    myComponent2.Length);
+            Mem.AreEqual(positions[0].x,            entities.Ids[0]);
+            Mem.AreEqual(positions[length - 1].x,   entities.Ids[length - 1]);
+            switch(chunkCount++) {
+                case 0:     Mem.AreEqual(999,   length);    Mem.AreSame(childArch,                  entities.Archetype); break;
+                case 1:     Mem.AreEqual(1,     length);    Mem.AreSame(store.StoreRoot.Archetype,  entities.Archetype); break;
+                default:    throw new InvalidOperationException("unexpected");
+            }
+        }
+        Mem.AreEqual(2, chunkCount);
+    }
+}
+
 public static class Test_ScriptSystems
 {
     [Test]
@@ -320,6 +383,66 @@ public static void Test_ScriptSystems_query_arg_count_5()
         ExecuteSystems(store, count);
     }
     
+    [Test]
+    public static void Test_ScriptSystems_query_arg_count_6()
+    {
+        var store = SetupTestStore();
+        var root  = store.StoreRoot;
+        root.AddScript(new SystemSet { argCount = 6 });
+        
+        var child = store.CreateEntity();
+        root.AddChild(child);
+        child.AddComponent(new Position(2, 0, 0));
+        child.AddComponent(new Rotation(2, 0, 0, 0));
+        child.AddComponent(new Scale3  (2, 0, 0));
+        child.AddComponent<Transform>();
+        child.AddComponent(new EntityName("child"));
+        child.AddComponent(new MyComponent1());
+        for (int n = 3; n <= 1000; n++) {
+            child = child.Archetype.CreateEntity();
+            child.Position      = new Position(n, 0, 0);
+            child.Rotation      = new Rotation(n, 0, 0, 0);
+            child.Scale3        = new Scale3  (n, 0, 0);
+            child.AddComponent(new MyComponent1());
+            child.Name.value    = "child";
+            root.AddChild(child);
+        }
+        CreateSystems(store);
+        int count = 10; // 10_000_000 ~ #PC: 1847 ms
+        ExecuteSystems(store, count);
+    }
+    
+    [Test]
+    public static void Test_ScriptSystems_query_arg_count_7()
+    {
+        var store = SetupTestStore();
+        var root  = store.StoreRoot;
+        root.AddScript(new SystemSet { argCount = 7 });
+        
+        var child = store.CreateEntity();
+        root.AddChild(child);
+        child.AddComponent(new Position(2, 0, 0));
+        child.AddComponent(new Rotation(2, 0, 0, 0));
+        child.AddComponent(new Scale3  (2, 0, 0));
+        child.AddComponent<Transform>();
+        child.AddComponent(new EntityName("child"));
+        child.AddComponent(new MyComponent1());
+        child.AddComponent(new MyComponent2());
+        for (int n = 3; n <= 1000; n++) {
+            child = child.Archetype.CreateEntity();
+            child.Position      = new Position(n, 0, 0);
+            child.Rotation      = new Rotation(n, 0, 0, 0);
+            child.Scale3        = new Scale3  (n, 0, 0);
+            child.AddComponent(new MyComponent1());
+            child.AddComponent(new MyComponent2());
+            child.Name.value    = "child";
+            root.AddChild(child);
+        }
+        CreateSystems(store);
+        int count = 10; // 10_000_000 ~ #PC: 1847 ms
+        ExecuteSystems(store, count);
+    }
+    
     internal static EntityStore SetupTestStore() {
         var store   = new EntityStore();
         
@@ -330,6 +453,7 @@ internal static EntityStore SetupTestStore() {
         root.AddComponent<Transform>();
         root.AddComponent<Scale3>();
         root.AddComponent<MyComponent1>();
+        root.AddComponent<MyComponent2>();
         store.SetStoreRoot(root);
         return store;
     }