diff --git a/Sia/Entities/Extensions/EntityHostExtensions.ForEach.cs b/Sia/Entities/Extensions/EntityHostExtensions.ForEach.cs
index a54ad7a..69be41d 100644
--- a/Sia/Entities/Extensions/EntityHostExtensions.ForEach.cs
+++ b/Sia/Entities/Extensions/EntityHostExtensions.ForEach.cs
@@ -8,7 +8,7 @@ public static partial class EntityHostExtensions
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static unsafe void ForEach<TRunner>(
-        this IEntityHost host, EntityHandler handler, TRunner runner)
+        this IEntityHost host, EntityHandler handler, TRunner runner, RunnerBarrier? barrier)
         where TRunner : IRunner
         => host.Handle(handler,
             static (IEntityHost host, in EntityHandler handler, int from, int to) => {
@@ -16,11 +16,11 @@ public static unsafe void ForEach<TRunner>(
                 for (int i = from; i != to; ++i) {
                     handler(new(slosts[i], host));
                 }
-            }, runner);
+            }, runner, barrier);
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static unsafe void ForEach<TRunner, TData>(
-        this IEntityHost host, in TData userData, EntityHandler<TData> handler, TRunner runner)
+        this IEntityHost host, in TData userData, EntityHandler<TData> handler, TRunner runner, RunnerBarrier? barrier)
         where TRunner : IRunner
         => host.Handle((userData, handler),
             static (IEntityHost host, in (TData, EntityHandler<TData>) entry, int from, int to) => {
@@ -30,43 +30,43 @@ public static unsafe void ForEach<TRunner, TData>(
                 for (int i = from; i != to; ++i) {
                     handler(data, new(slosts[i], host));
                 }
-            }, runner);
+            }, runner, barrier);
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static unsafe void ForEach<TRunner>(
-        this IEntityHost host, SimpleEntityHandler handler, TRunner runner)
+        this IEntityHost host, SimpleEntityHandler handler, TRunner runner, RunnerBarrier? barrier)
         where TRunner : IRunner
         => host.ForEach(handler,
             static (in SimpleEntityHandler handler, in EntityRef entity)
-                => handler(entity), runner);
+                => handler(entity), runner, barrier);
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static unsafe void ForEach<TRunner, TData>(
-        this IEntityHost host, in TData userData, SimpleEntityHandler<TData> handler, TRunner runner)
+        this IEntityHost host, in TData userData, SimpleEntityHandler<TData> handler, TRunner runner, RunnerBarrier? barrier)
         where TRunner : IRunner
         => host.ForEach((handler, userData),
             static (in (SimpleEntityHandler<TData>, TData) data, in EntityRef entity)
-                => data.Item1(data.Item2, entity), runner);
+                => data.Item1(data.Item2, entity), runner, barrier);
 
     #region CurrentThreadRunner
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static unsafe void ForEach(this IEntityHost host, EntityHandler handler)
-        => host.ForEach(handler, CurrentThreadRunner.Instance);
+        => host.ForEach(handler, CurrentThreadRunner.Instance, barrier: null);
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static unsafe void ForEach<TData>(
         this IEntityHost host, in TData data, EntityHandler<TData> handler)
-        => host.ForEach(data, handler, CurrentThreadRunner.Instance);
+        => host.ForEach(data, handler, CurrentThreadRunner.Instance, barrier: null);
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static unsafe void ForEach(this IEntityHost host, SimpleEntityHandler handler)
-        => host.ForEach(handler, CurrentThreadRunner.Instance);
+        => host.ForEach(handler, CurrentThreadRunner.Instance, barrier: null);
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static unsafe void ForEach<TData>(
         this IEntityHost host, in TData data, SimpleEntityHandler<TData> handler)
-        => host.ForEach(data, handler, CurrentThreadRunner.Instance);
+        => host.ForEach(data, handler, CurrentThreadRunner.Instance, barrier: null);
     
     #endregion // CurrentThreadRunner
 
@@ -74,21 +74,37 @@ public static unsafe void ForEach<TData>(
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static unsafe void ForEachOnParallel(this IEntityHost host, EntityHandler handler)
-        => host.ForEach(handler, ParallelRunner.Default);
+    {
+        var barrier = RunnerBarrier.Get();
+        host.ForEach(handler, ParallelRunner.Default, barrier);
+        barrier.WaitAndReturn();
+    }
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static unsafe void ForEachOnParallel<TData>(
         this IEntityHost host, in TData data, EntityHandler<TData> handler)
-        => host.ForEach(data, handler, ParallelRunner.Default);
+    {
+        var barrier = RunnerBarrier.Get();
+        host.ForEach(data, handler, ParallelRunner.Default, barrier);
+        barrier.WaitAndReturn();
+    }
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static unsafe void ForEachOnParallel(this IEntityHost host, SimpleEntityHandler handler)
-        => host.ForEach(handler, ParallelRunner.Default);
+    {
+        var barrier = RunnerBarrier.Get();
+        host.ForEach(handler, ParallelRunner.Default, barrier);
+        barrier.WaitAndReturn();
+    }
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static unsafe void ForEachOnParallel<TData>(
         this IEntityHost host, in TData data, SimpleEntityHandler<TData> handler)
-        => host.ForEach(data, handler, ParallelRunner.Default);
+    {
+        var barrier = RunnerBarrier.Get();
+        host.ForEach(data, handler, ParallelRunner.Default, barrier);
+        barrier.WaitAndReturn();
+    }
     
     #endregion // ParallelRunner
 
@@ -98,7 +114,7 @@ public static unsafe void ForEachOnParallel<TData>(
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public unsafe static void ForSlice<TRunner, C1>(
-        this IEntityHost host, ComponentHandler<C1> handler, TRunner runner)
+        this IEntityHost host, ComponentHandler<C1> handler, TRunner runner, RunnerBarrier? barrier)
         where TRunner : IRunner
         => host.Handle(handler,
             static (IEntityHost host, in ComponentHandler<C1> handler, int from, int to) => {
@@ -111,11 +127,11 @@ public unsafe static void ForSlice<TRunner, C1>(
                     ref var byteRef = ref host.UnsafeGetByteRef(slots[i]);
                     handler(ref c1Offset.Get(ref byteRef));
                 }
-            }, runner);
+            }, runner, barrier);
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public unsafe static void ForSlice<TRunner, C1, C2>(
-        this IEntityHost host, ComponentHandler<C1, C2> handler, TRunner runner)
+        this IEntityHost host, ComponentHandler<C1, C2> handler, TRunner runner, RunnerBarrier? barrier)
         where TRunner : IRunner
         => host.Handle(handler,
             static (IEntityHost host, in ComponentHandler<C1, C2> handler, int from, int to) => {
@@ -131,11 +147,11 @@ public unsafe static void ForSlice<TRunner, C1, C2>(
                         ref c1Offset.Get(ref byteRef),
                         ref c2Offset.Get(ref byteRef));
                 }
-            }, runner);
+            }, runner, barrier);
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public unsafe static void ForSlice<TRunner, C1, C2, C3>(
-        this IEntityHost host, ComponentHandler<C1, C2, C3> handler, TRunner runner)
+        this IEntityHost host, ComponentHandler<C1, C2, C3> handler, TRunner runner, RunnerBarrier? barrier)
         where TRunner : IRunner
         => host.Handle(handler,
             static (IEntityHost host, in ComponentHandler<C1, C2, C3> handler, int from, int to) => {
@@ -153,11 +169,11 @@ ref c1Offset.Get(ref byteRef),
                         ref c2Offset.Get(ref byteRef),
                         ref c3Offset.Get(ref byteRef));
                 }
-            }, runner);
+            }, runner, barrier);
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public unsafe static void ForSlice<TRunner, C1, C2, C3, C4>(
-        this IEntityHost host, ComponentHandler<C1, C2, C3, C4> handler, TRunner runner)
+        this IEntityHost host, ComponentHandler<C1, C2, C3, C4> handler, TRunner runner, RunnerBarrier? barrier)
         where TRunner : IRunner
         => host.Handle(handler,
             static (IEntityHost host, in ComponentHandler<C1, C2, C3, C4> handler, int from, int to) => {
@@ -177,11 +193,11 @@ ref c2Offset.Get(ref byteRef),
                         ref c3Offset.Get(ref byteRef),
                         ref c4Offset.Get(ref byteRef));
                 }
-            }, runner);
+            }, runner, barrier);
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public unsafe static void ForSlice<TRunner, C1, C2, C3, C4, C5>(
-        this IEntityHost host, ComponentHandler<C1, C2, C3, C4, C5> handler, TRunner runner)
+        this IEntityHost host, ComponentHandler<C1, C2, C3, C4, C5> handler, TRunner runner, RunnerBarrier? barrier)
         where TRunner : IRunner
         => host.Handle(handler,
             static (IEntityHost host, in ComponentHandler<C1, C2, C3, C4, C5> handler, int from, int to) => {
@@ -203,11 +219,11 @@ ref c3Offset.Get(ref byteRef),
                         ref c4Offset.Get(ref byteRef),
                         ref c5Offset.Get(ref byteRef));
                 }
-            }, runner);
+            }, runner, barrier);
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public unsafe static void ForSlice<TRunner, C1, C2, C3, C4, C5, C6>(
-        this IEntityHost host, ComponentHandler<C1, C2, C3, C4, C5, C6> handler, TRunner runner)
+        this IEntityHost host, ComponentHandler<C1, C2, C3, C4, C5, C6> handler, TRunner runner, RunnerBarrier? barrier)
         where TRunner : IRunner
         => host.Handle(handler,
             static (IEntityHost host, in ComponentHandler<C1, C2, C3, C4, C5, C6> handler, int from, int to) => {
@@ -231,11 +247,11 @@ ref c4Offset.Get(ref byteRef),
                         ref c5Offset.Get(ref byteRef),
                         ref c6Offset.Get(ref byteRef));
                 }
-            }, runner);
+            }, runner, barrier);
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public unsafe static void ForSlice<TRunner, TData, C1>(
-        this IEntityHost host, in TData userData, DataComponentHandler<TData, C1> handler, TRunner runner)
+        this IEntityHost host, in TData userData, DataComponentHandler<TData, C1> handler, TRunner runner, RunnerBarrier? barrier)
         where TRunner : IRunner
         => host.Handle((handler, userData),
             static (IEntityHost host, in (DataComponentHandler<TData, C1>, TData) data, int from, int to) => {
@@ -251,11 +267,11 @@ public unsafe static void ForSlice<TRunner, TData, C1>(
                     ref var byteRef = ref host.UnsafeGetByteRef(slots[i]);
                     handler(userData, ref c1Offset.Get(ref byteRef));
                 }
-            }, runner);
+            }, runner, barrier);
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public unsafe static void ForSlice<TRunner, TData, C1, C2>(
-        this IEntityHost host, in TData userData, DataComponentHandler<TData, C1, C2> handler, TRunner runner)
+        this IEntityHost host, in TData userData, DataComponentHandler<TData, C1, C2> handler, TRunner runner, RunnerBarrier? barrier)
         where TRunner : IRunner
         => host.Handle((handler, userData),
             static (IEntityHost host, in (DataComponentHandler<TData, C1, C2>, TData) data, int from, int to) => {
@@ -274,11 +290,11 @@ public unsafe static void ForSlice<TRunner, TData, C1, C2>(
                         ref c1Offset.Get(ref byteRef),
                         ref c2Offset.Get(ref byteRef));
                 }
-            }, runner);
+            }, runner, barrier);
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public unsafe static void ForSlice<TRunner, TData, C1, C2, C3>(
-        this IEntityHost host, in TData userData, DataComponentHandler<TData, C1, C2, C3> handler, TRunner runner)
+        this IEntityHost host, in TData userData, DataComponentHandler<TData, C1, C2, C3> handler, TRunner runner, RunnerBarrier? barrier)
         where TRunner : IRunner
         => host.Handle((handler, userData),
             static (IEntityHost host, in (DataComponentHandler<TData, C1, C2, C3>, TData) data, int from, int to) => {
@@ -299,11 +315,11 @@ ref c1Offset.Get(ref byteRef),
                         ref c2Offset.Get(ref byteRef),
                         ref c3Offset.Get(ref byteRef));
                 }
-            }, runner);
+            }, runner, barrier);
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public unsafe static void ForSlice<TRunner, TData, C1, C2, C3, C4>(
-        this IEntityHost host, in TData userData, DataComponentHandler<TData, C1, C2, C3, C4> handler, TRunner runner)
+        this IEntityHost host, in TData userData, DataComponentHandler<TData, C1, C2, C3, C4> handler, TRunner runner, RunnerBarrier? barrier)
         where TRunner : IRunner
         => host.Handle((handler, userData),
             static (IEntityHost host, in (DataComponentHandler<TData, C1, C2, C3, C4>, TData) data, int from, int to) => {
@@ -326,11 +342,11 @@ ref c2Offset.Get(ref byteRef),
                         ref c3Offset.Get(ref byteRef),
                         ref c4Offset.Get(ref byteRef));
                 }
-            }, runner);
+            }, runner, barrier);
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public unsafe static void ForSlice<TRunner, TData, C1, C2, C3, C4, C5>(
-        this IEntityHost host, in TData userData, DataComponentHandler<TData, C1, C2, C3, C4, C5> handler, TRunner runner)
+        this IEntityHost host, in TData userData, DataComponentHandler<TData, C1, C2, C3, C4, C5> handler, TRunner runner, RunnerBarrier? barrier)
         where TRunner : IRunner
         => host.Handle((handler, userData),
             static (IEntityHost host, in (DataComponentHandler<TData, C1, C2, C3, C4, C5>, TData) data, int from, int to) => {
@@ -355,11 +371,11 @@ ref c3Offset.Get(ref byteRef),
                         ref c4Offset.Get(ref byteRef),
                         ref c5Offset.Get(ref byteRef));
                 }
-            }, runner);
+            }, runner, barrier);
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public unsafe static void ForSlice<TRunner, TData, C1, C2, C3, C4, C5, C6>(
-        this IEntityHost host, in TData userData, DataComponentHandler<TData, C1, C2, C3, C4, C5, C6> handler, TRunner runner)
+        this IEntityHost host, in TData userData, DataComponentHandler<TData, C1, C2, C3, C4, C5, C6> handler, TRunner runner, RunnerBarrier? barrier)
         where TRunner : IRunner
         => host.Handle((handler, userData),
             static (IEntityHost host, in (DataComponentHandler<TData, C1, C2, C3, C4, C5, C6>, TData) data, int from, int to) => {
@@ -386,69 +402,69 @@ ref c4Offset.Get(ref byteRef),
                         ref c5Offset.Get(ref byteRef),
                         ref c6Offset.Get(ref byteRef));
                 }
-            }, runner);
+            }, runner, barrier);
 
     #region CurrentThreadRunner
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public unsafe static void ForSlice<C1>(
         this IEntityHost host, ComponentHandler<C1> handler)
-        => host.ForSlice(handler, CurrentThreadRunner.Instance);
+        => host.ForSlice(handler, CurrentThreadRunner.Instance, barrier: null);
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public unsafe static void ForSlice<C1, C2>(
         this IEntityHost host, ComponentHandler<C1, C2> handler)
-        => host.ForSlice(handler, CurrentThreadRunner.Instance);
+        => host.ForSlice(handler, CurrentThreadRunner.Instance, barrier: null);
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public unsafe static void ForSlice<C1, C2, C3>(
         this IEntityHost host, ComponentHandler<C1, C2, C3> handler)
-        => host.ForSlice(handler, CurrentThreadRunner.Instance);
+        => host.ForSlice(handler, CurrentThreadRunner.Instance, barrier: null);
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public unsafe static void ForSlice<C1, C2, C3, C4>(
         this IEntityHost host, ComponentHandler<C1, C2, C3, C4> handler)
-        => host.ForSlice(handler, CurrentThreadRunner.Instance);
+        => host.ForSlice(handler, CurrentThreadRunner.Instance, barrier: null);
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public unsafe static void ForSlice<C1, C2, C3, C4, C5>(
         this IEntityHost host, ComponentHandler<C1, C2, C3, C4, C5> handler)
-        => host.ForSlice(handler, CurrentThreadRunner.Instance);
+        => host.ForSlice(handler, CurrentThreadRunner.Instance, barrier: null);
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public unsafe static void ForSlice<C1, C2, C3, C4, C5, C6>(
         this IEntityHost host, ComponentHandler<C1, C2, C3, C4, C5, C6> handler)
-        => host.ForSlice(handler, CurrentThreadRunner.Instance);
+        => host.ForSlice(handler, CurrentThreadRunner.Instance, barrier: null);
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public unsafe static void ForSlice<TData, C1>(
         this IEntityHost host, in TData userData, DataComponentHandler<TData, C1> handler)
-        => host.ForSlice(userData, handler, CurrentThreadRunner.Instance);
+        => host.ForSlice(userData, handler, CurrentThreadRunner.Instance, barrier: null);
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public unsafe static void ForSlice<TData, C1, C2>(
         this IEntityHost host, in TData userData, DataComponentHandler<TData, C1, C2> handler)
-        => host.ForSlice(userData, handler, CurrentThreadRunner.Instance);
+        => host.ForSlice(userData, handler, CurrentThreadRunner.Instance, barrier: null);
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public unsafe static void ForSlice<TData, C1, C2, C3>(
         this IEntityHost host, in TData userData, DataComponentHandler<TData, C1, C2, C3> handler)
-        => host.ForSlice(userData, handler, CurrentThreadRunner.Instance);
+        => host.ForSlice(userData, handler, CurrentThreadRunner.Instance, barrier: null);
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public unsafe static void ForSlice<TData, C1, C2, C3, C4>(
         this IEntityHost host, in TData userData, DataComponentHandler<TData, C1, C2, C3, C4> handler)
-        => host.ForSlice(userData, handler, CurrentThreadRunner.Instance);
+        => host.ForSlice(userData, handler, CurrentThreadRunner.Instance, barrier: null);
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public unsafe static void ForSlice<TData, C1, C2, C3, C4, C5>(
         this IEntityHost host, in TData userData, DataComponentHandler<TData, C1, C2, C3, C4, C5> handler)
-        => host.ForSlice(userData, handler, CurrentThreadRunner.Instance);
+        => host.ForSlice(userData, handler, CurrentThreadRunner.Instance, barrier: null);
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public unsafe static void ForSlice<TData, C1, C2, C3, C4, C5, C6>(
         this IEntityHost host, in TData userData, DataComponentHandler<TData, C1, C2, C3, C4, C5, C6> handler)
-        => host.ForSlice(userData, handler, CurrentThreadRunner.Instance);
+        => host.ForSlice(userData, handler, CurrentThreadRunner.Instance, barrier: null);
     
     #endregion // CurrentThreadRunner
 
@@ -457,62 +473,110 @@ public unsafe static void ForSlice<TData, C1, C2, C3, C4, C5, C6>(
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public unsafe static void ForSliceOnParallel<C1>(
         this IEntityHost host, ComponentHandler<C1> handler)
-        => host.ForSlice(handler, ParallelRunner.Default);
+    {
+        var barrier = RunnerBarrier.Get();
+        host.ForSlice(handler, ParallelRunner.Default, barrier);
+        barrier.WaitAndReturn();
+    }
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public unsafe static void ForSliceOnParallel<C1, C2>(
         this IEntityHost host, ComponentHandler<C1, C2> handler)
-        => host.ForSlice(handler, ParallelRunner.Default);
+    {
+        var barrier = RunnerBarrier.Get();
+        host.ForSlice(handler, ParallelRunner.Default, barrier);
+        barrier.WaitAndReturn();
+    }
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public unsafe static void ForSliceOnParallel<C1, C2, C3>(
         this IEntityHost host, ComponentHandler<C1, C2, C3> handler)
-        => host.ForSlice(handler, ParallelRunner.Default);
+    {
+        var barrier = RunnerBarrier.Get();
+        host.ForSlice(handler, ParallelRunner.Default, barrier);
+        barrier.WaitAndReturn();
+    }
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public unsafe static void ForSliceOnParallel<C1, C2, C3, C4>(
         this IEntityHost host, ComponentHandler<C1, C2, C3, C4> handler)
-        => host.ForSlice(handler, ParallelRunner.Default);
+    {
+        var barrier = RunnerBarrier.Get();
+        host.ForSlice(handler, ParallelRunner.Default, barrier);
+        barrier.WaitAndReturn();
+    }
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public unsafe static void ForSliceOnParallel<C1, C2, C3, C4, C5>(
         this IEntityHost host, ComponentHandler<C1, C2, C3, C4, C5> handler)
-        => host.ForSlice(handler, ParallelRunner.Default);
+    {
+        var barrier = RunnerBarrier.Get();
+        host.ForSlice(handler, ParallelRunner.Default, barrier);
+        barrier.WaitAndReturn();
+    }
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public unsafe static void ForSliceOnParallel<C1, C2, C3, C4, C5, C6>(
         this IEntityHost host, ComponentHandler<C1, C2, C3, C4, C5, C6> handler)
-        => host.ForSlice(handler, ParallelRunner.Default);
+    {
+        var barrier = RunnerBarrier.Get();
+        host.ForSlice(handler, ParallelRunner.Default, barrier);
+        barrier.WaitAndReturn();
+    }
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public unsafe static void ForSliceOnParallel<TData, C1>(
         this IEntityHost host, in TData userData, DataComponentHandler<TData, C1> handler)
-        => host.ForSlice(userData, handler, ParallelRunner.Default);
+    {
+        var barrier = RunnerBarrier.Get();
+        host.ForSlice(userData, handler, ParallelRunner.Default, barrier);
+        barrier.WaitAndReturn();
+    }
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public unsafe static void ForSliceOnParallel<TData, C1, C2>(
         this IEntityHost host, in TData userData, DataComponentHandler<TData, C1, C2> handler)
-        => host.ForSlice(userData, handler, ParallelRunner.Default);
+    {
+        var barrier = RunnerBarrier.Get();
+        host.ForSlice(userData, handler, ParallelRunner.Default, barrier);
+        barrier.WaitAndReturn();
+    }
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public unsafe static void ForSliceOnParallel<TData, C1, C2, C3>(
         this IEntityHost host, in TData userData, DataComponentHandler<TData, C1, C2, C3> handler)
-        => host.ForSlice(userData, handler, ParallelRunner.Default);
+    {
+        var barrier = RunnerBarrier.Get();
+        host.ForSlice(userData, handler, ParallelRunner.Default, barrier);
+        barrier.WaitAndReturn();
+    }
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public unsafe static void ForSliceOnParallel<TData, C1, C2, C3, C4>(
         this IEntityHost host, in TData userData, DataComponentHandler<TData, C1, C2, C3, C4> handler)
-        => host.ForSlice(userData, handler, ParallelRunner.Default);
+    {
+        var barrier = RunnerBarrier.Get();
+        host.ForSlice(userData, handler, ParallelRunner.Default, barrier);
+        barrier.WaitAndReturn();
+    }
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public unsafe static void ForSliceOnParallel<TData, C1, C2, C3, C4, C5>(
         this IEntityHost host, in TData userData, DataComponentHandler<TData, C1, C2, C3, C4, C5> handler)
-        => host.ForSlice(userData, handler, ParallelRunner.Default);
+    {
+        var barrier = RunnerBarrier.Get();
+        host.ForSlice(userData, handler, ParallelRunner.Default, barrier);
+        barrier.WaitAndReturn();
+    }
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public unsafe static void ForSliceOnParallel<TData, C1, C2, C3, C4, C5, C6>(
         this IEntityHost host, in TData userData, DataComponentHandler<TData, C1, C2, C3, C4, C5, C6> handler)
-        => host.ForSlice(userData, handler, ParallelRunner.Default);
+    {
+        var barrier = RunnerBarrier.Get();
+        host.ForSlice(userData, handler, ParallelRunner.Default, barrier);
+        barrier.WaitAndReturn();
+    }
     
     #endregion // ParallelRunner
 
@@ -522,7 +586,7 @@ public unsafe static void ForSliceOnParallel<TData, C1, C2, C3, C4, C5, C6>(
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public unsafe static void Filter<TRunner, C1>(
-        this IEntityHost host, ComponentFilter<C1> filter, EntityHandler handler, TRunner runner)
+        this IEntityHost host, ComponentFilter<C1> filter, EntityHandler handler, TRunner runner, RunnerBarrier? barrier)
         where TRunner : IRunner
         => host.Handle((filter, handler),
             static (IEntityHost host, in (ComponentFilter<C1>, EntityHandler) fs, int from, int to) => {
@@ -540,11 +604,11 @@ public unsafe static void Filter<TRunner, C1>(
                         handler(new(slot, host));
                     }
                 }
-            }, runner);
+            }, runner, barrier);
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public unsafe static void Filter<TRunner, C1, C2>(
-        this IEntityHost host, ComponentFilter<C1, C2> filter, EntityHandler handler, TRunner runner)
+        this IEntityHost host, ComponentFilter<C1, C2> filter, EntityHandler handler, TRunner runner, RunnerBarrier? barrier)
         where TRunner : IRunner
         => host.Handle((filter, handler),
             static (IEntityHost host, in (ComponentFilter<C1, C2>, EntityHandler) fs, int from, int to) => {
@@ -565,11 +629,11 @@ ref c2Offset.Get(ref byteRef))) {
                         handler(new(slot, host));
                     }
                 }
-            }, runner);
+            }, runner, barrier);
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public unsafe static void Filter<TRunner, C1, C2, C3>(
-        this IEntityHost host, ComponentFilter<C1, C2, C3> filter, EntityHandler handler, TRunner runner)
+        this IEntityHost host, ComponentFilter<C1, C2, C3> filter, EntityHandler handler, TRunner runner, RunnerBarrier? barrier)
         where TRunner : IRunner
         => host.Handle((filter, handler),
             static (IEntityHost host, in (ComponentFilter<C1, C2, C3>, EntityHandler) fs, int from, int to) => {
@@ -592,11 +656,11 @@ ref c3Offset.Get(ref byteRef))) {
                         handler(new(slot, host));
                     }
                 }
-            }, runner);
+            }, runner, barrier);
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public unsafe static void Filter<TRunner, C1, C2, C3, C4>(
-        this IEntityHost host, ComponentFilter<C1, C2, C3, C4> filter, EntityHandler handler, TRunner runner)
+        this IEntityHost host, ComponentFilter<C1, C2, C3, C4> filter, EntityHandler handler, TRunner runner, RunnerBarrier? barrier)
         where TRunner : IRunner
         => host.Handle((filter, handler),
             static (IEntityHost host, in (ComponentFilter<C1, C2, C3, C4>, EntityHandler) fs, int from, int to) => {
@@ -621,11 +685,11 @@ ref c4Offset.Get(ref byteRef))) {
                         handler(new(slot, host));
                     }
                 }
-            }, runner);
+            }, runner, barrier);
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public unsafe static void Filter<TRunner, C1, C2, C3, C4, C5>(
-        this IEntityHost host, ComponentFilter<C1, C2, C3, C4, C5> filter, EntityHandler handler, TRunner runner)
+        this IEntityHost host, ComponentFilter<C1, C2, C3, C4, C5> filter, EntityHandler handler, TRunner runner, RunnerBarrier? barrier)
         where TRunner : IRunner
         => host.Handle((filter, handler),
             static (IEntityHost host, in (ComponentFilter<C1, C2, C3, C4, C5>, EntityHandler) fs, int from, int to) => {
@@ -652,11 +716,11 @@ ref c5Offset.Get(ref byteRef))) {
                         handler(new(slot, host));
                     }
                 }
-            }, runner);
+            }, runner, barrier);
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public unsafe static void Filter<TRunner, C1, C2, C3, C4, C5, C6>(
-        this IEntityHost host, ComponentFilter<C1, C2, C3, C4, C5, C6> filter, EntityHandler handler, TRunner runner)
+        this IEntityHost host, ComponentFilter<C1, C2, C3, C4, C5, C6> filter, EntityHandler handler, TRunner runner, RunnerBarrier? barrier)
         where TRunner : IRunner
         => host.Handle((filter, handler),
             static (IEntityHost host, in (ComponentFilter<C1, C2, C3, C4, C5, C6>, EntityHandler) fs, int from, int to) => {
@@ -685,11 +749,11 @@ ref c6Offset.Get(ref byteRef))) {
                         handler(new(slot, host));
                     }
                 }
-            }, runner);
+            }, runner, barrier);
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public unsafe static void Filter<TRunner, TData, C1>(
-        this IEntityHost host, in TData userData, DataComponentFilter<TData, C1> filter, EntityHandler<TData> handler, TRunner runner)
+        this IEntityHost host, in TData userData, DataComponentFilter<TData, C1> filter, EntityHandler<TData> handler, TRunner runner, RunnerBarrier? barrier)
         where TRunner : IRunner
         => host.Handle((filter, handler, userData),
             static (IEntityHost host, in (DataComponentFilter<TData, C1>, EntityHandler<TData>, TData) data, int from, int to) => {
@@ -710,11 +774,11 @@ public unsafe static void Filter<TRunner, TData, C1>(
                         handler(userData, new(slot, host));
                     }
                 }
-            }, runner);
+            }, runner, barrier);
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public unsafe static void Filter<TRunner, TData, C1, C2>(
-        this IEntityHost host, in TData userData, DataComponentFilter<TData, C1, C2> filter, EntityHandler<TData> handler, TRunner runner)
+        this IEntityHost host, in TData userData, DataComponentFilter<TData, C1, C2> filter, EntityHandler<TData> handler, TRunner runner, RunnerBarrier? barrier)
         where TRunner : IRunner
         => host.Handle((filter, handler, userData),
             static (IEntityHost host, in (DataComponentFilter<TData, C1, C2>, EntityHandler<TData>, TData) data, int from, int to) => {
@@ -738,11 +802,11 @@ ref c2Offset.Get(ref byteRef))) {
                         handler(userData, new(slot, host));
                     }
                 }
-            }, runner);
+            }, runner, barrier);
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public unsafe static void Filter<TRunner, TData, C1, C2, C3>(
-        this IEntityHost host, in TData userData, DataComponentFilter<TData, C1, C2, C3> filter, EntityHandler<TData> handler, TRunner runner)
+        this IEntityHost host, in TData userData, DataComponentFilter<TData, C1, C2, C3> filter, EntityHandler<TData> handler, TRunner runner, RunnerBarrier? barrier)
         where TRunner : IRunner
         => host.Handle((filter, handler, userData),
             static (IEntityHost host, in (DataComponentFilter<TData, C1, C2, C3>, EntityHandler<TData>, TData) data, int from, int to) => {
@@ -768,11 +832,11 @@ ref c3Offset.Get(ref byteRef))) {
                         handler(userData, new(slot, host));
                     }
                 }
-            }, runner);
+            }, runner, barrier);
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public unsafe static void Filter<TRunner, TData, C1, C2, C3, C4>(
-        this IEntityHost host, in TData userData, DataComponentFilter<TData, C1, C2, C3, C4> filter, EntityHandler<TData> handler, TRunner runner)
+        this IEntityHost host, in TData userData, DataComponentFilter<TData, C1, C2, C3, C4> filter, EntityHandler<TData> handler, TRunner runner, RunnerBarrier? barrier)
         where TRunner : IRunner
         => host.Handle((filter, handler, userData),
             static (IEntityHost host, in (DataComponentFilter<TData, C1, C2, C3, C4>, EntityHandler<TData>, TData) data, int from, int to) => {
@@ -800,11 +864,11 @@ ref c4Offset.Get(ref byteRef))) {
                         handler(userData, new(slot, host));
                     }
                 }
-            }, runner);
+            }, runner, barrier);
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public unsafe static void Filter<TRunner, TData, C1, C2, C3, C4, C5>(
-        this IEntityHost host, in TData userData, DataComponentFilter<TData, C1, C2, C3, C4, C5> filter, EntityHandler<TData> handler, TRunner runner)
+        this IEntityHost host, in TData userData, DataComponentFilter<TData, C1, C2, C3, C4, C5> filter, EntityHandler<TData> handler, TRunner runner, RunnerBarrier? barrier)
         where TRunner : IRunner
         => host.Handle((filter, handler, userData),
             static (IEntityHost host, in (DataComponentFilter<TData, C1, C2, C3, C4, C5>, EntityHandler<TData>, TData) data, int from, int to) => {
@@ -834,11 +898,11 @@ ref c5Offset.Get(ref byteRef))) {
                         handler(userData, new(slot, host));
                     }
                 }
-            }, runner);
+            }, runner, barrier);
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public unsafe static void Filter<TRunner, TData, C1, C2, C3, C4, C5, C6>(
-        this IEntityHost host, in TData userData, DataComponentFilter<TData, C1, C2, C3, C4, C5, C6> filter, EntityHandler<TData> handler, TRunner runner)
+        this IEntityHost host, in TData userData, DataComponentFilter<TData, C1, C2, C3, C4, C5, C6> filter, EntityHandler<TData> handler, TRunner runner, RunnerBarrier? barrier)
         where TRunner : IRunner
         => host.Handle((filter, handler, userData),
             static (IEntityHost host, in (DataComponentFilter<TData, C1, C2, C3, C4, C5, C6>, EntityHandler<TData>, TData) data, int from, int to) => {
@@ -870,133 +934,181 @@ ref c6Offset.Get(ref byteRef))) {
                         handler(userData, new(slot, host));
                     }
                 }
-            }, runner);
+            }, runner, barrier);
 
     #region CurrentThreadRunner
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public unsafe static void Filter<C1>(
         this IEntityHost host, ComponentFilter<C1> filter, EntityHandler handler)
-        => host.Filter(filter, handler, CurrentThreadRunner.Instance);
+        => host.Filter(filter, handler, CurrentThreadRunner.Instance, barrier: null);
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public unsafe static void Filter<C1, C2>(
         this IEntityHost host, ComponentFilter<C1, C2> filter, EntityHandler handler)
-        => host.Filter(filter, handler, CurrentThreadRunner.Instance);
+        => host.Filter(filter, handler, CurrentThreadRunner.Instance, barrier: null);
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public unsafe static void Filter<C1, C2, C3>(
         this IEntityHost host, ComponentFilter<C1, C2, C3> filter, EntityHandler handler)
-        => host.Filter(filter, handler, CurrentThreadRunner.Instance);
+        => host.Filter(filter, handler, CurrentThreadRunner.Instance, barrier: null);
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public unsafe static void Filter<C1, C2, C3, C4>(
         this IEntityHost host, ComponentFilter<C1, C2, C3, C4> filter, EntityHandler handler)
-        => host.Filter(filter, handler, CurrentThreadRunner.Instance);
+        => host.Filter(filter, handler, CurrentThreadRunner.Instance, barrier: null);
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public unsafe static void Filter<C1, C2, C3, C4, C5>(
         this IEntityHost host, ComponentFilter<C1, C2, C3, C4, C5> filter, EntityHandler handler)
-        => host.Filter(filter, handler, CurrentThreadRunner.Instance);
+        => host.Filter(filter, handler, CurrentThreadRunner.Instance, barrier: null);
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public unsafe static void Filter<C1, C2, C3, C4, C5, C6>(
         this IEntityHost host, ComponentFilter<C1, C2, C3, C4, C5, C6> filter, EntityHandler handler)
-        => host.Filter(filter, handler, CurrentThreadRunner.Instance);
+        => host.Filter(filter, handler, CurrentThreadRunner.Instance, barrier: null);
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public unsafe static void Filter<TData, C1>(
         this IEntityHost host, in TData userData, DataComponentFilter<TData, C1> filter, EntityHandler<TData> handler)
-        => host.Filter(userData, filter, handler, CurrentThreadRunner.Instance);
+        => host.Filter(userData, filter, handler, CurrentThreadRunner.Instance, barrier: null);
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public unsafe static void Filter<TData, C1, C2>(
         this IEntityHost host, in TData userData, DataComponentFilter<TData, C1, C2> filter, EntityHandler<TData> handler)
-        => host.Filter(userData, filter, handler, CurrentThreadRunner.Instance);
+        => host.Filter(userData, filter, handler, CurrentThreadRunner.Instance, barrier: null);
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public unsafe static void Filter<TData, C1, C2, C3>(
         this IEntityHost host, in TData userData, DataComponentFilter<TData, C1, C2, C3> filter, EntityHandler<TData> handler)
-        => host.Filter(userData, filter, handler, CurrentThreadRunner.Instance);
+        => host.Filter(userData, filter, handler, CurrentThreadRunner.Instance, barrier: null);
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public unsafe static void Filter<TData, C1, C2, C3, C4>(
         this IEntityHost host, in TData userData, DataComponentFilter<TData, C1, C2, C3, C4> filter, EntityHandler<TData> handler)
-        => host.Filter(userData, filter, handler, CurrentThreadRunner.Instance);
+        => host.Filter(userData, filter, handler, CurrentThreadRunner.Instance, barrier: null);
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public unsafe static void Filter<TData, C1, C2, C3, C4, C5>(
         this IEntityHost host, in TData userData, DataComponentFilter<TData, C1, C2, C3, C4, C5> filter, EntityHandler<TData> handler)
-        => host.Filter(userData, filter, handler, CurrentThreadRunner.Instance);
+        => host.Filter(userData, filter, handler, CurrentThreadRunner.Instance, barrier: null);
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public unsafe static void Filter<TData, C1, C2, C3, C4, C5, C6>(
         this IEntityHost host, in TData userData, DataComponentFilter<TData, C1, C2, C3, C4, C5, C6> filter, EntityHandler<TData> handler)
-        => host.Filter(userData, filter, handler, CurrentThreadRunner.Instance);
+        => host.Filter(userData, filter, handler, CurrentThreadRunner.Instance, barrier: null);
     
-    #endregion // ParallelRunner
+    #endregion // CurrentThreadRunner
 
     #region ParallelRunner
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public unsafe static void FilterOnParallel<C1>(
         this IEntityHost host, ComponentFilter<C1> filter, EntityHandler handler)
-        => host.Filter(filter, handler, ParallelRunner.Default);
+    {
+        var barrier = RunnerBarrier.Get();
+        host.Filter(filter, handler, ParallelRunner.Default, barrier);
+        barrier.WaitAndReturn();
+    }
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public unsafe static void FilterOnParallel<C1, C2>(
         this IEntityHost host, ComponentFilter<C1, C2> filter, EntityHandler handler)
-        => host.Filter(filter, handler, ParallelRunner.Default);
+    {
+        var barrier = RunnerBarrier.Get();
+        host.Filter(filter, handler, ParallelRunner.Default, barrier);
+        barrier.WaitAndReturn();
+    }
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public unsafe static void FilterOnParallel<C1, C2, C3>(
         this IEntityHost host, ComponentFilter<C1, C2, C3> filter, EntityHandler handler)
-        => host.Filter(filter, handler, ParallelRunner.Default);
+    {
+        var barrier = RunnerBarrier.Get();
+        host.Filter(filter, handler, ParallelRunner.Default, barrier);
+        barrier.WaitAndReturn();
+    }
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public unsafe static void FilterOnParallel<C1, C2, C3, C4>(
         this IEntityHost host, ComponentFilter<C1, C2, C3, C4> filter, EntityHandler handler)
-        => host.Filter(filter, handler, ParallelRunner.Default);
+    {
+        var barrier = RunnerBarrier.Get();
+        host.Filter(filter, handler, ParallelRunner.Default, barrier);
+        barrier.WaitAndReturn();
+    }
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public unsafe static void FilterOnParallel<C1, C2, C3, C4, C5>(
         this IEntityHost host, ComponentFilter<C1, C2, C3, C4, C5> filter, EntityHandler handler)
-        => host.Filter(filter, handler, ParallelRunner.Default);
+    {
+        var barrier = RunnerBarrier.Get();
+        host.Filter(filter, handler, ParallelRunner.Default, barrier);
+        barrier.WaitAndReturn();
+    }
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public unsafe static void FilterOnParallel<C1, C2, C3, C4, C5, C6>(
         this IEntityHost host, ComponentFilter<C1, C2, C3, C4, C5, C6> filter, EntityHandler handler)
-        => host.Filter(filter, handler, ParallelRunner.Default);
+    {
+        var barrier = RunnerBarrier.Get();
+        host.Filter(filter, handler, ParallelRunner.Default, barrier);
+        barrier.WaitAndReturn();
+    }
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public unsafe static void FilterOnParallel<TData, C1>(
         this IEntityHost host, in TData userData, DataComponentFilter<TData, C1> filter, EntityHandler<TData> handler)
-        => host.Filter(userData, filter, handler, ParallelRunner.Default);
+    {
+        var barrier = RunnerBarrier.Get();
+        host.Filter(userData, filter, handler, ParallelRunner.Default, barrier);
+        barrier.WaitAndReturn();
+    }
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public unsafe static void FilterOnParallel<TData, C1, C2>(
         this IEntityHost host, in TData userData, DataComponentFilter<TData, C1, C2> filter, EntityHandler<TData> handler)
-        => host.Filter(userData, filter, handler, ParallelRunner.Default);
+    {
+        var barrier = RunnerBarrier.Get();
+        host.Filter(userData, filter, handler, ParallelRunner.Default, barrier);
+        barrier.WaitAndReturn();
+    }
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public unsafe static void FilterOnParallel<TData, C1, C2, C3>(
         this IEntityHost host, in TData userData, DataComponentFilter<TData, C1, C2, C3> filter, EntityHandler<TData> handler)
-        => host.Filter(userData, filter, handler, ParallelRunner.Default);
+    {
+        var barrier = RunnerBarrier.Get();
+        host.Filter(userData, filter, handler, ParallelRunner.Default, barrier);
+        barrier.WaitAndReturn();
+    }
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public unsafe static void FilterOnParallel<TData, C1, C2, C3, C4>(
         this IEntityHost host, in TData userData, DataComponentFilter<TData, C1, C2, C3, C4> filter, EntityHandler<TData> handler)
-        => host.Filter(userData, filter, handler, ParallelRunner.Default);
+    {
+        var barrier = RunnerBarrier.Get();
+        host.Filter(userData, filter, handler, ParallelRunner.Default, barrier);
+        barrier.WaitAndReturn();
+    }
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public unsafe static void FilterOnParallel<TData, C1, C2, C3, C4, C5>(
         this IEntityHost host, in TData userData, DataComponentFilter<TData, C1, C2, C3, C4, C5> filter, EntityHandler<TData> handler)
-        => host.Filter(userData, filter, handler, ParallelRunner.Default);
+    {
+        var barrier = RunnerBarrier.Get();
+        host.Filter(userData, filter, handler, ParallelRunner.Default, barrier);
+        barrier.WaitAndReturn();
+    }
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public unsafe static void FilterOnParallel<TData, C1, C2, C3, C4, C5, C6>(
         this IEntityHost host, in TData userData, DataComponentFilter<TData, C1, C2, C3, C4, C5, C6> filter, EntityHandler<TData> handler)
-        => host.Filter(userData, filter, handler, ParallelRunner.Default);
+    {
+        var barrier = RunnerBarrier.Get();
+        host.Filter(userData, filter, handler, ParallelRunner.Default, barrier);
+        barrier.WaitAndReturn();
+    }
     
     #endregion // ParallelRunner
 
diff --git a/Sia/Entities/Extensions/EntityHostExtensions.Handle.cs b/Sia/Entities/Extensions/EntityHostExtensions.Handle.cs
index 3e8a2d7..3ca1497 100644
--- a/Sia/Entities/Extensions/EntityHostExtensions.Handle.cs
+++ b/Sia/Entities/Extensions/EntityHostExtensions.Handle.cs
@@ -11,7 +11,7 @@ private readonly record struct HandleData<TData>(
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static unsafe void Handle<TRunner>(
-        this IEntityHost host, EntityHostRangeHandler handler, TRunner runner, RunnerBarrier barrier)
+        this IEntityHost host, EntityHostRangeHandler handler, TRunner runner, RunnerBarrier? barrier)
         where TRunner : IRunner
     {
         var count = host.Count;
@@ -24,20 +24,10 @@ public static unsafe void Handle<TRunner>(
             barrier);
     }
 
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static unsafe void Handle<TRunner>(
-        this IEntityHost host, EntityHostRangeHandler handler, TRunner runner)
-        where TRunner : IRunner
-    {
-        var barrier = RunnerBarrier.Get();
-        host.Handle(handler, runner, barrier);
-        barrier.WaitAndReturn();
-    }
-
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static unsafe void Handle<TRunner, TData>(
         this IEntityHost host, in TData userData, EntityHostRangeHandler<TData> handler,
-        TRunner runner, RunnerBarrier barrier)
+        TRunner runner, RunnerBarrier? barrier)
         where TRunner : IRunner
     {
         var count = host.Count;
@@ -50,23 +40,39 @@ public static unsafe void Handle<TRunner, TData>(
             barrier);
     }
 
+    #region CurrentThreadRunner
+
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static unsafe void Handle<TRunner, TData>(
-        this IEntityHost host, in TData userData, EntityHostRangeHandler<TData> handler, TRunner runner)
-        where TRunner : IRunner
-    {
-        var barrier = RunnerBarrier.Get();
-        host.Handle(userData, handler, runner, barrier);
-        barrier.WaitAndReturn();
-    }
+    public static unsafe void Handle(
+        this IEntityHost host, EntityHostRangeHandler handler)
+        => host.Handle(handler, CurrentThreadRunner.Instance, barrier: null);
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static unsafe void Handle<TData>(
+        this IEntityHost host, in TData data, EntityHostRangeHandler<TData> handler)
+        => host.Handle(data, handler, CurrentThreadRunner.Instance, barrier: null);
+
+    #endregion // CurrentThreadRunner
+
+    #region ParallelRunner
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static unsafe void HandleOnParallel(
         this IEntityHost host, EntityHostRangeHandler handler)
-        => host.Handle(handler, ParallelRunner.Default);
+    {
+        var barrier = RunnerBarrier.Get();
+        host.Handle(handler, ParallelRunner.Default, barrier);
+        barrier.WaitAndReturn();
+    }
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static unsafe void HandleOnParallel<TData>(
         this IEntityHost host, in TData data, EntityHostRangeHandler<TData> handler)
-        => host.Handle(data, handler, ParallelRunner.Default);
+    {
+        var barrier = RunnerBarrier.Get();
+        host.Handle(data, handler, ParallelRunner.Default, barrier);
+        barrier.WaitAndReturn();
+    }
+    
+    #endregion // ParallelRunner
 }
\ No newline at end of file
diff --git a/Sia/Entities/Extensions/EntityHostExtensions.Record.cs b/Sia/Entities/Extensions/EntityHostExtensions.Record.cs
index 3a50c0a..fc084ec 100644
--- a/Sia/Entities/Extensions/EntityHostExtensions.Record.cs
+++ b/Sia/Entities/Extensions/EntityHostExtensions.Record.cs
@@ -9,7 +9,7 @@ public static partial class EntityHostExtensions
     #region EntityRecorder
 
     public unsafe static void Record<TRunner, TResult>(
-        this IEntityHost host, Span<TResult> span, EntityRecorder<TResult> recorder, TRunner runner)
+        this IEntityHost host, Span<TResult> span, EntityRecorder<TResult> recorder, TRunner runner, RunnerBarrier? barrier)
         where TRunner : IRunner
     {
         GuardSpanLength(span, host.Count);
@@ -33,12 +33,12 @@ public unsafe static void Record<TRunner, TResult>(
                         recorder(new(slots[i], host),
                             out *(pointer + Interlocked.Increment(ref index)));
                     }
-                }, runner);
+                }, runner, barrier);
         }
     }
 
     public unsafe static void Record<TRunner, TData, TResult>(
-        this IEntityHost host, Span<TResult> span, in TData userData, EntityRecorder<TData, TResult> recorder, TRunner runner)
+        this IEntityHost host, Span<TResult> span, in TData userData, EntityRecorder<TData, TResult> recorder, TRunner runner, RunnerBarrier? barrier)
         where TRunner : IRunner
     {
         GuardSpanLength(span, host.Count);
@@ -63,7 +63,7 @@ public unsafe static void Record<TRunner, TData, TResult>(
                         recorder(userData, new(slots[i], host),
                             out *(pointer + Interlocked.Increment(ref index)));
                     }
-                }, runner);
+                }, runner, barrier);
         }
     }
 
@@ -71,23 +71,23 @@ private static void IdEntityRecorder(in EntityRef entity, out EntityRef result)
         => result = entity;
 
     public unsafe static void Record<TRunner>(
-        this IEntityHost host, Span<EntityRef> span, TRunner runner)
+        this IEntityHost host, Span<EntityRef> span, TRunner runner, RunnerBarrier? barrier)
         where TRunner : IRunner
-        => host.Record(span, IdEntityRecorder, runner);
+        => host.Record(span, IdEntityRecorder, runner, barrier);
 
     #region CurrentThreadRunner
 
     public unsafe static void Record<TResult>(
         this IEntityHost host, Span<TResult> span, EntityRecorder<TResult> recorder)
-        => host.Record(span, recorder, CurrentThreadRunner.Instance);
+        => host.Record(span, recorder, CurrentThreadRunner.Instance, barrier: null);
 
     public unsafe static void Record<TData, TResult>(
         this IEntityHost host, Span<TResult> span, in TData userData, EntityRecorder<TData, TResult> recorder)
-        => host.Record(span, userData, recorder, CurrentThreadRunner.Instance);
+        => host.Record(span, userData, recorder, CurrentThreadRunner.Instance, barrier: null);
 
     public unsafe static void Record(
         this IEntityHost host, Span<EntityRef> span)
-        => host.Record(span, IdEntityRecorder, CurrentThreadRunner.Instance);
+        => host.Record(span, IdEntityRecorder, CurrentThreadRunner.Instance, barrier: null);
 
     #endregion // CurrentThreadRunner
     
@@ -95,15 +95,27 @@ public unsafe static void Record(
 
     public unsafe static void RecordOnParallel<TResult>(
         this IEntityHost host, Span<TResult> span, EntityRecorder<TResult> recorder)
-        => host.Record(span, recorder, ParallelRunner.Default);
+    {
+        var barrier = RunnerBarrier.Get();
+        host.Record(span, recorder, ParallelRunner.Default, barrier);
+        barrier.WaitAndReturn();
+    }
 
     public unsafe static void RecordOnParallel<TData, TResult>(
         this IEntityHost host, Span<TResult> span, in TData userData, EntityRecorder<TData, TResult> recorder)
-        => host.Record(span, userData, recorder, ParallelRunner.Default);
+    {
+        var barrier = RunnerBarrier.Get();
+        host.Record(span, userData, recorder, ParallelRunner.Default, barrier);
+        barrier.WaitAndReturn();
+    }
 
     public unsafe static void RecordOnParallel(
         this IEntityHost host, Span<EntityRef> span)
-        => host.Record(span, IdEntityRecorder, ParallelRunner.Default);
+    {
+        var barrier = RunnerBarrier.Get();
+        host.Record(span, IdEntityRecorder, ParallelRunner.Default, barrier);
+        barrier.WaitAndReturn();
+    }
 
     #endregion // ParallelRunner
 
@@ -112,7 +124,7 @@ public unsafe static void RecordOnParallel(
     #region ComponentRecorder
 
     public unsafe static void RecordSlices<TRunner, C1, TResult>(
-        this IEntityHost host, Span<TResult> span, ComponentRecorder<C1, TResult> recorder, TRunner runner)
+        this IEntityHost host, Span<TResult> span, ComponentRecorder<C1, TResult> recorder, TRunner runner, RunnerBarrier? barrier)
         where TRunner : IRunner
     {
         GuardSpanLength(span, host.Count);
@@ -129,12 +141,12 @@ public unsafe static void RecordSlices<TRunner, C1, TResult>(
                 static (in CompRecordData<C1, TResult> data, ref C1 c1) => {
                     data.Recorder(ref c1,
                         out *(data.Pointer + Interlocked.Increment(ref *data.Index)));
-                }, runner);
+                }, runner, barrier);
         }
     }
 
     public unsafe static void RecordSlices<TRunner, C1, C2, TResult>(
-        this IEntityHost host, Span<TResult> span, ComponentRecorder<C1, C2, TResult> recorder, TRunner runner)
+        this IEntityHost host, Span<TResult> span, ComponentRecorder<C1, C2, TResult> recorder, TRunner runner, RunnerBarrier? barrier)
         where TRunner : IRunner
     {
         GuardSpanLength(span, host.Count);
@@ -151,12 +163,12 @@ public unsafe static void RecordSlices<TRunner, C1, C2, TResult>(
                 static (in CompRecordData<C1, C2, TResult> data, ref C1 c1, ref C2 c2) => {
                     data.Recorder(ref c1, ref c2,
                         out *(data.Pointer + Interlocked.Increment(ref *data.Index)));
-                }, runner);
+                }, runner, barrier);
         }
     }
 
     public unsafe static void RecordSlices<TRunner, C1, C2, C3, TResult>(
-        this IEntityHost host, Span<TResult> span, ComponentRecorder<C1, C2, C3, TResult> recorder, TRunner runner)
+        this IEntityHost host, Span<TResult> span, ComponentRecorder<C1, C2, C3, TResult> recorder, TRunner runner, RunnerBarrier? barrier)
         where TRunner : IRunner
     {
         GuardSpanLength(span, host.Count);
@@ -173,12 +185,12 @@ public unsafe static void RecordSlices<TRunner, C1, C2, C3, TResult>(
                 static (in CompRecordData<C1, C2, C3, TResult> data, ref C1 c1, ref C2 c2, ref C3 c3) => {
                     data.Recorder(ref c1, ref c2, ref c3,
                         out *(data.Pointer + Interlocked.Increment(ref *data.Index)));
-                }, runner);
+                }, runner, barrier);
         }
     }
 
     public unsafe static void RecordSlices<TRunner, C1, C2, C3, C4, TResult>(
-        this IEntityHost host, Span<TResult> span, ComponentRecorder<C1, C2, C3, C4, TResult> recorder, TRunner runner)
+        this IEntityHost host, Span<TResult> span, ComponentRecorder<C1, C2, C3, C4, TResult> recorder, TRunner runner, RunnerBarrier? barrier)
         where TRunner : IRunner
     {
         GuardSpanLength(span, host.Count);
@@ -195,12 +207,12 @@ public unsafe static void RecordSlices<TRunner, C1, C2, C3, C4, TResult>(
                 static (in CompRecordData<C1, C2, C3, C4, TResult> data, ref C1 c1, ref C2 c2, ref C3 c3, ref C4 c4) => {
                     data.Recorder(ref c1, ref c2, ref c3, ref c4,
                         out *(data.Pointer + Interlocked.Increment(ref *data.Index)));
-                }, runner);
+                }, runner, barrier);
         }
     }
 
     public unsafe static void RecordSlices<TRunner, C1, C2, C3, C4, C5, TResult>(
-        this IEntityHost host, Span<TResult> span, ComponentRecorder<C1, C2, C3, C4, C5, TResult> recorder, TRunner runner)
+        this IEntityHost host, Span<TResult> span, ComponentRecorder<C1, C2, C3, C4, C5, TResult> recorder, TRunner runner, RunnerBarrier? barrier)
         where TRunner : IRunner
     {
         GuardSpanLength(span, host.Count);
@@ -217,12 +229,12 @@ public unsafe static void RecordSlices<TRunner, C1, C2, C3, C4, C5, TResult>(
                 static (in CompRecordData<C1, C2, C3, C4, C5, TResult> data, ref C1 c1, ref C2 c2, ref C3 c3, ref C4 c4, ref C5 c5) => {
                     data.Recorder(ref c1, ref c2, ref c3, ref c4, ref c5,
                         out *(data.Pointer + Interlocked.Increment(ref *data.Index)));
-                }, runner);
+                }, runner, barrier);
         }
     }
 
     public unsafe static void RecordSlices<TRunner, C1, C2, C3, C4, C5, C6, TResult>(
-        this IEntityHost host, Span<TResult> span, ComponentRecorder<C1, C2, C3, C4, C5, C6, TResult> recorder, TRunner runner)
+        this IEntityHost host, Span<TResult> span, ComponentRecorder<C1, C2, C3, C4, C5, C6, TResult> recorder, TRunner runner, RunnerBarrier? barrier)
         where TRunner : IRunner
     {
         GuardSpanLength(span, host.Count);
@@ -239,12 +251,12 @@ public unsafe static void RecordSlices<TRunner, C1, C2, C3, C4, C5, C6, TResult>
                 static (in CompRecordData<C1, C2, C3, C4, C5, C6, TResult> data, ref C1 c1, ref C2 c2, ref C3 c3, ref C4 c4, ref C5 c5, ref C6 c6) => {
                     data.Recorder(ref c1, ref c2, ref c3, ref c4, ref c5, ref c6,
                         out *(data.Pointer + Interlocked.Increment(ref *data.Index)));
-                }, runner);
+                }, runner, barrier);
         }
     }
 
     public unsafe static void RecordSlices<TRunner, TData, C1, TResult>(
-        this IEntityHost host, Span<TResult> span, in TData userData, DataComponentRecorder<TData, C1, TResult> recorder, TRunner runner)
+        this IEntityHost host, Span<TResult> span, in TData userData, DataComponentRecorder<TData, C1, TResult> recorder, TRunner runner, RunnerBarrier? barrier)
         where TRunner : IRunner
     {
         GuardSpanLength(span, host.Count);
@@ -263,12 +275,12 @@ public unsafe static void RecordSlices<TRunner, TData, C1, TResult>(
                     data.Recorder(data.UserData,
                         ref c1,
                         out *(data.Pointer + Interlocked.Increment(ref *data.Index)));
-                }, runner);
+                }, runner, barrier);
         }
     }
 
     public unsafe static void RecordSlices<TRunner, TData, C1, C2, TResult>(
-        this IEntityHost host, Span<TResult> span, in TData userData, DataComponentRecorder<TData, C1, C2, TResult> recorder, TRunner runner)
+        this IEntityHost host, Span<TResult> span, in TData userData, DataComponentRecorder<TData, C1, C2, TResult> recorder, TRunner runner, RunnerBarrier? barrier)
         where TRunner : IRunner
     {
         GuardSpanLength(span, host.Count);
@@ -287,12 +299,12 @@ public unsafe static void RecordSlices<TRunner, TData, C1, C2, TResult>(
                     data.Recorder(data.UserData,
                         ref c1, ref c2,
                         out *(data.Pointer + Interlocked.Increment(ref *data.Index)));
-                }, runner);
+                }, runner, barrier);
         }
     }
 
     public unsafe static void RecordSlices<TRunner, TData, C1, C2, C3, TResult>(
-        this IEntityHost host, Span<TResult> span, in TData userData, DataComponentRecorder<TData, C1, C2, C3, TResult> recorder, TRunner runner)
+        this IEntityHost host, Span<TResult> span, in TData userData, DataComponentRecorder<TData, C1, C2, C3, TResult> recorder, TRunner runner, RunnerBarrier? barrier)
         where TRunner : IRunner
     {
         GuardSpanLength(span, host.Count);
@@ -311,12 +323,12 @@ public unsafe static void RecordSlices<TRunner, TData, C1, C2, C3, TResult>(
                     data.Recorder(data.UserData,
                         ref c1, ref c2, ref c3,
                         out *(data.Pointer + Interlocked.Increment(ref *data.Index)));
-                }, runner);
+                }, runner, barrier);
         }
     }
 
     public unsafe static void RecordSlices<TRunner, TData, C1, C2, C3, C4, TResult>(
-        this IEntityHost host, Span<TResult> span, in TData userData, DataComponentRecorder<TData, C1, C2, C3, C4, TResult> recorder, TRunner runner)
+        this IEntityHost host, Span<TResult> span, in TData userData, DataComponentRecorder<TData, C1, C2, C3, C4, TResult> recorder, TRunner runner, RunnerBarrier? barrier)
         where TRunner : IRunner
     {
         GuardSpanLength(span, host.Count);
@@ -335,12 +347,12 @@ public unsafe static void RecordSlices<TRunner, TData, C1, C2, C3, C4, TResult>(
                     data.Recorder(data.UserData,
                         ref c1, ref c2, ref c3, ref c4,
                         out *(data.Pointer + Interlocked.Increment(ref *data.Index)));
-                }, runner);
+                }, runner, barrier);
         }
     }
 
     public unsafe static void RecordSlices<TRunner, TData, C1, C2, C3, C4, C5, TResult>(
-        this IEntityHost host, Span<TResult> span, in TData userData, DataComponentRecorder<TData, C1, C2, C3, C4, C5, TResult> recorder, TRunner runner)
+        this IEntityHost host, Span<TResult> span, in TData userData, DataComponentRecorder<TData, C1, C2, C3, C4, C5, TResult> recorder, TRunner runner, RunnerBarrier? barrier)
         where TRunner : IRunner
     {
         GuardSpanLength(span, host.Count);
@@ -359,12 +371,12 @@ public unsafe static void RecordSlices<TRunner, TData, C1, C2, C3, C4, C5, TResu
                     data.Recorder(data.UserData,
                         ref c1, ref c2, ref c3, ref c4, ref c5,
                         out *(data.Pointer + Interlocked.Increment(ref *data.Index)));
-                }, runner);
+                }, runner, barrier);
         }
     }
 
     public unsafe static void RecordSlices<TRunner, TData, C1, C2, C3, C4, C5, C6, TResult>(
-        this IEntityHost host, Span<TResult> span, in TData userData, DataComponentRecorder<TData, C1, C2, C3, C4, C5, C6, TResult> recorder, TRunner runner)
+        this IEntityHost host, Span<TResult> span, in TData userData, DataComponentRecorder<TData, C1, C2, C3, C4, C5, C6, TResult> recorder, TRunner runner, RunnerBarrier? barrier)
         where TRunner : IRunner
     {
         GuardSpanLength(span, host.Count);
@@ -383,7 +395,7 @@ public unsafe static void RecordSlices<TRunner, TData, C1, C2, C3, C4, C5, C6, T
                     data.Recorder(data.UserData,
                         ref c1, ref c2, ref c3, ref c4, ref c5, ref c6,
                         out *(data.Pointer + Interlocked.Increment(ref *data.Index)));
-                }, runner);
+                }, runner, barrier);
         }
     }
 
@@ -391,51 +403,51 @@ public unsafe static void RecordSlices<TRunner, TData, C1, C2, C3, C4, C5, C6, T
 
     public unsafe static void RecordSlices<C1, TResult>(
         this IEntityHost host, Span<TResult> span, ComponentRecorder<C1, TResult> recorder)
-        => host.RecordSlices(span, recorder, CurrentThreadRunner.Instance);
+        => host.RecordSlices(span, recorder, CurrentThreadRunner.Instance, barrier: null);
 
     public unsafe static void RecordSlices<C1, C2, TResult>(
         this IEntityHost host, Span<TResult> span, ComponentRecorder<C1, C2, TResult> recorder)
-        => host.RecordSlices(span, recorder, CurrentThreadRunner.Instance);
+        => host.RecordSlices(span, recorder, CurrentThreadRunner.Instance, barrier: null);
 
     public unsafe static void RecordSlices<C1, C2, C3, TResult>(
         this IEntityHost host, Span<TResult> span, ComponentRecorder<C1, C2, C3, TResult> recorder)
-        => host.RecordSlices(span, recorder, CurrentThreadRunner.Instance);
+        => host.RecordSlices(span, recorder, CurrentThreadRunner.Instance, barrier: null);
 
     public unsafe static void RecordSlices<C1, C2, C3, C4, TResult>(
         this IEntityHost host, Span<TResult> span, ComponentRecorder<C1, C2, C3, C4, TResult> recorder)
-        => host.RecordSlices(span, recorder, CurrentThreadRunner.Instance);
+        => host.RecordSlices(span, recorder, CurrentThreadRunner.Instance, barrier: null);
 
     public unsafe static void RecordSlices<C1, C2, C3, C4, C5, TResult>(
         this IEntityHost host, Span<TResult> span, ComponentRecorder<C1, C2, C3, C4, C5, TResult> recorder)
-        => host.RecordSlices(span, recorder, CurrentThreadRunner.Instance);
+        => host.RecordSlices(span, recorder, CurrentThreadRunner.Instance, barrier: null);
 
     public unsafe static void RecordSlices<C1, C2, C3, C4, C5, C6, TResult>(
         this IEntityHost host, Span<TResult> span, ComponentRecorder<C1, C2, C3, C4, C5, C6, TResult> recorder)
-        => host.RecordSlices(span, recorder, CurrentThreadRunner.Instance);
+        => host.RecordSlices(span, recorder, CurrentThreadRunner.Instance, barrier: null);
 
     public unsafe static void RecordSlices<TData, C1, TResult>(
         this IEntityHost host, Span<TResult> span, in TData userData, DataComponentRecorder<TData, C1, TResult> recorder)
-        => host.RecordSlices(span, userData, recorder, CurrentThreadRunner.Instance);
+        => host.RecordSlices(span, userData, recorder, CurrentThreadRunner.Instance, barrier: null);
 
     public unsafe static void RecordSlices<TData, C1, C2, TResult>(
         this IEntityHost host, Span<TResult> span, in TData userData, DataComponentRecorder<TData, C1, C2, TResult> recorder)
-        => host.RecordSlices(span, userData, recorder, CurrentThreadRunner.Instance);
+        => host.RecordSlices(span, userData, recorder, CurrentThreadRunner.Instance, barrier: null);
 
     public unsafe static void RecordSlices<TData, C1, C2, C3, TResult>(
         this IEntityHost host, Span<TResult> span, in TData userData, DataComponentRecorder<TData, C1, C2, C3, TResult> recorder)
-        => host.RecordSlices(span, userData, recorder, CurrentThreadRunner.Instance);
+        => host.RecordSlices(span, userData, recorder, CurrentThreadRunner.Instance, barrier: null);
 
     public unsafe static void RecordSlices<TData, C1, C2, C3, C4, TResult>(
         this IEntityHost host, Span<TResult> span, in TData userData, DataComponentRecorder<TData, C1, C2, C3, C4, TResult> recorder)
-        => host.RecordSlices(span, userData, recorder, CurrentThreadRunner.Instance);
+        => host.RecordSlices(span, userData, recorder, CurrentThreadRunner.Instance, barrier: null);
 
     public unsafe static void RecordSlices<TData, C1, C2, C3, C4, C5, TResult>(
         this IEntityHost host, Span<TResult> span, in TData userData, DataComponentRecorder<TData, C1, C2, C3, C4, C5, TResult> recorder)
-        => host.RecordSlices(span, userData, recorder, CurrentThreadRunner.Instance);
+        => host.RecordSlices(span, userData, recorder, CurrentThreadRunner.Instance, barrier: null);
 
     public unsafe static void RecordSlices<TData, C1, C2, C3, C4, C5, C6, TResult>(
         this IEntityHost host, Span<TResult> span, in TData userData, DataComponentRecorder<TData, C1, C2, C3, C4, C5, C6, TResult> recorder)
-        => host.RecordSlices(span, userData, recorder, CurrentThreadRunner.Instance);
+        => host.RecordSlices(span, userData, recorder, CurrentThreadRunner.Instance, barrier: null);
 
     #endregion // CurrentThreadRunner
 
@@ -443,51 +455,99 @@ public unsafe static void RecordSlices<TData, C1, C2, C3, C4, C5, C6, TResult>(
 
     public unsafe static void RecordSlicesOnParallel<C1, TResult>(
         this IEntityHost host, Span<TResult> span, ComponentRecorder<C1, TResult> recorder)
-        => host.RecordSlices(span, recorder, ParallelRunner.Default);
+    {
+        var barrier = RunnerBarrier.Get();
+        host.RecordSlices(span, recorder, ParallelRunner.Default, barrier);
+        barrier.WaitAndReturn();
+    }
 
     public unsafe static void RecordSlicesOnParallel<C1, C2, TResult>(
         this IEntityHost host, Span<TResult> span, ComponentRecorder<C1, C2, TResult> recorder)
-        => host.RecordSlices(span, recorder, ParallelRunner.Default);
+    {
+        var barrier = RunnerBarrier.Get();
+        host.RecordSlices(span, recorder, ParallelRunner.Default, barrier);
+        barrier.WaitAndReturn();
+    }
 
     public unsafe static void RecordSlicesOnParallel<C1, C2, C3, TResult>(
         this IEntityHost host, Span<TResult> span, ComponentRecorder<C1, C2, C3, TResult> recorder)
-        => host.RecordSlices(span, recorder, ParallelRunner.Default);
+    {
+        var barrier = RunnerBarrier.Get();
+        host.RecordSlices(span, recorder, ParallelRunner.Default, barrier);
+        barrier.WaitAndReturn();
+    }
 
     public unsafe static void RecordSlicesOnParallel<C1, C2, C3, C4, TResult>(
         this IEntityHost host, Span<TResult> span, ComponentRecorder<C1, C2, C3, C4, TResult> recorder)
-        => host.RecordSlices(span, recorder, ParallelRunner.Default);
+    {
+        var barrier = RunnerBarrier.Get();
+        host.RecordSlices(span, recorder, ParallelRunner.Default, barrier);
+        barrier.WaitAndReturn();
+    }
 
     public unsafe static void RecordSlicesOnParallel<C1, C2, C3, C4, C5, TResult>(
         this IEntityHost host, Span<TResult> span, ComponentRecorder<C1, C2, C3, C4, C5, TResult> recorder)
-        => host.RecordSlices(span, recorder, ParallelRunner.Default);
+    {
+        var barrier = RunnerBarrier.Get();
+        host.RecordSlices(span, recorder, ParallelRunner.Default, barrier);
+        barrier.WaitAndReturn();
+    }
 
     public unsafe static void RecordSlicesOnParallel<C1, C2, C3, C4, C5, C6, TResult>(
         this IEntityHost host, Span<TResult> span, ComponentRecorder<C1, C2, C3, C4, C5, C6, TResult> recorder)
-        => host.RecordSlices(span, recorder, ParallelRunner.Default);
+    {
+        var barrier = RunnerBarrier.Get();
+        host.RecordSlices(span, recorder, ParallelRunner.Default, barrier);
+        barrier.WaitAndReturn();
+    }
 
     public unsafe static void RecordSlicesOnParallel<TData, C1, TResult>(
         this IEntityHost host, Span<TResult> span, in TData userData, DataComponentRecorder<TData, C1, TResult> recorder)
-        => host.RecordSlices(span, userData, recorder, ParallelRunner.Default);
+    {
+        var barrier = RunnerBarrier.Get();
+        host.RecordSlices(span, userData, recorder, ParallelRunner.Default, barrier);
+        barrier.WaitAndReturn();
+    }
 
     public unsafe static void RecordSlicesOnParallel<TData, C1, C2, TResult>(
         this IEntityHost host, Span<TResult> span, in TData userData, DataComponentRecorder<TData, C1, C2, TResult> recorder)
-        => host.RecordSlices(span, userData, recorder, ParallelRunner.Default);
+    {
+        var barrier = RunnerBarrier.Get();
+        host.RecordSlices(span, userData, recorder, ParallelRunner.Default, barrier);
+        barrier.WaitAndReturn();
+    }
 
     public unsafe static void RecordSlicesOnParallel<TData, C1, C2, C3, TResult>(
         this IEntityHost host, Span<TResult> span, in TData userData, DataComponentRecorder<TData, C1, C2, C3, TResult> recorder)
-        => host.RecordSlices(span, userData, recorder, ParallelRunner.Default);
+    {
+        var barrier = RunnerBarrier.Get();
+        host.RecordSlices(span, userData, recorder, ParallelRunner.Default, barrier);
+        barrier.WaitAndReturn();
+    }
 
     public unsafe static void RecordSlicesOnParallel<TData, C1, C2, C3, C4, TResult>(
         this IEntityHost host, Span<TResult> span, in TData userData, DataComponentRecorder<TData, C1, C2, C3, C4, TResult> recorder)
-        => host.RecordSlices(span, userData, recorder, ParallelRunner.Default);
+    {
+        var barrier = RunnerBarrier.Get();
+        host.RecordSlices(span, userData, recorder, ParallelRunner.Default, barrier);
+        barrier.WaitAndReturn();
+    }
 
     public unsafe static void RecordSlicesOnParallel<TData, C1, C2, C3, C4, C5, TResult>(
         this IEntityHost host, Span<TResult> span, in TData userData, DataComponentRecorder<TData, C1, C2, C3, C4, C5, TResult> recorder)
-        => host.RecordSlices(span, userData, recorder, ParallelRunner.Default);
+    {
+        var barrier = RunnerBarrier.Get();
+        host.RecordSlices(span, userData, recorder, ParallelRunner.Default, barrier);
+        barrier.WaitAndReturn();
+    }
 
     public unsafe static void RecordSlicesOnParallel<TData, C1, C2, C3, C4, C5, C6, TResult>(
         this IEntityHost host, Span<TResult> span, in TData userData, DataComponentRecorder<TData, C1, C2, C3, C4, C5, C6, TResult> recorder)
-        => host.RecordSlices(span, userData, recorder, ParallelRunner.Default);
+    {
+        var barrier = RunnerBarrier.Get();
+        host.RecordSlices(span, userData, recorder, ParallelRunner.Default, barrier);
+        barrier.WaitAndReturn();
+    }
     #endregion // ParallelRunner
 
     #endregion // ComponentRecorder
diff --git a/Sia/Entities/Extensions/EntityQueryExtensions.ForEach.cs b/Sia/Entities/Extensions/EntityQueryExtensions.ForEach.cs
index 0060f4c..d4afef7 100644
--- a/Sia/Entities/Extensions/EntityQueryExtensions.ForEach.cs
+++ b/Sia/Entities/Extensions/EntityQueryExtensions.ForEach.cs
@@ -8,7 +8,7 @@ public static partial class EntityQueryExtensions
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static unsafe void ForEach<TRunner>(
-        this IEntityQuery query, EntityHandler handler, TRunner runner)
+        this IEntityQuery query, EntityHandler handler, TRunner runner, RunnerBarrier? barrier)
         where TRunner : IRunner
         => query.Handle(handler,
             static (IEntityHost host, in EntityHandler handler, int from, int to) => {
@@ -16,11 +16,11 @@ public static unsafe void ForEach<TRunner>(
                 for (int i = from; i != to; ++i) {
                     handler(new(slosts[i], host));
                 }
-            }, runner);
+            }, runner, barrier);
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static unsafe void ForEach<TRunner, TData>(
-        this IEntityQuery query, in TData userData, EntityHandler<TData> handler, TRunner runner)
+        this IEntityQuery query, in TData userData, EntityHandler<TData> handler, TRunner runner, RunnerBarrier? barrier)
         where TRunner : IRunner
         => query.Handle((userData, handler),
             static (IEntityHost host, in (TData, EntityHandler<TData>) entry, int from, int to) => {
@@ -30,43 +30,43 @@ public static unsafe void ForEach<TRunner, TData>(
                 for (int i = from; i != to; ++i) {
                     handler(data, new(slosts[i], host));
                 }
-            }, runner);
+            }, runner, barrier);
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static unsafe void ForEach<TRunner>(
-        this IEntityQuery query, SimpleEntityHandler handler, TRunner runner)
+        this IEntityQuery query, SimpleEntityHandler handler, TRunner runner, RunnerBarrier? barrier)
         where TRunner : IRunner
         => query.ForEach(handler,
             static (in SimpleEntityHandler handler, in EntityRef entity)
-                => handler(entity), runner);
+                => handler(entity), runner, barrier);
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static unsafe void ForEach<TRunner, TData>(
-        this IEntityQuery query, in TData userData, SimpleEntityHandler<TData> handler, TRunner runner)
+        this IEntityQuery query, in TData userData, SimpleEntityHandler<TData> handler, TRunner runner, RunnerBarrier? barrier)
         where TRunner : IRunner
         => query.ForEach((handler, userData),
             static (in (SimpleEntityHandler<TData>, TData) data, in EntityRef entity)
-                => data.Item1(data.Item2, entity), runner);
+                => data.Item1(data.Item2, entity), runner, barrier);
 
     #region CurrentThreadRunner
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static unsafe void ForEach(this IEntityQuery query, EntityHandler handler)
-        => query.ForEach(handler, CurrentThreadRunner.Instance);
+        => query.ForEach(handler, CurrentThreadRunner.Instance, barrier: null);
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static unsafe void ForEach<TData>(
         this IEntityQuery query, in TData data, EntityHandler<TData> handler)
-        => query.ForEach(data, handler, CurrentThreadRunner.Instance);
+        => query.ForEach(data, handler, CurrentThreadRunner.Instance, barrier: null);
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static unsafe void ForEach(this IEntityQuery query, SimpleEntityHandler handler)
-        => query.ForEach(handler, CurrentThreadRunner.Instance);
+        => query.ForEach(handler, CurrentThreadRunner.Instance, barrier: null);
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static unsafe void ForEach<TData>(
         this IEntityQuery query, in TData data, SimpleEntityHandler<TData> handler)
-        => query.ForEach(data, handler, CurrentThreadRunner.Instance);
+        => query.ForEach(data, handler, CurrentThreadRunner.Instance, barrier: null);
     
     #endregion // CurrentThreadRunner
 
@@ -74,21 +74,37 @@ public static unsafe void ForEach<TData>(
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static unsafe void ForEachOnParallel(this IEntityQuery query, EntityHandler handler)
-        => query.ForEach(handler, ParallelRunner.Default);
+    {
+        var barrier = RunnerBarrier.Get();
+        query.ForEach(handler, ParallelRunner.Default, barrier);
+        barrier.WaitAndReturn();
+    }
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static unsafe void ForEachOnParallel<TData>(
         this IEntityQuery query, in TData data, EntityHandler<TData> handler)
-        => query.ForEach(data, handler, ParallelRunner.Default);
+    {
+        var barrier = RunnerBarrier.Get();
+        query.ForEach(data, handler, ParallelRunner.Default, barrier);
+        barrier.WaitAndReturn();
+    }
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static unsafe void ForEachOnParallel(this IEntityQuery query, SimpleEntityHandler handler)
-        => query.ForEach(handler, ParallelRunner.Default);
+    {
+        var barrier = RunnerBarrier.Get();
+        query.ForEach(handler, ParallelRunner.Default, barrier);
+        barrier.WaitAndReturn();
+    }
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static unsafe void ForEachOnParallel<TData>(
         this IEntityQuery query, in TData data, SimpleEntityHandler<TData> handler)
-        => query.ForEach(data, handler, ParallelRunner.Default);
+    {
+        var barrier = RunnerBarrier.Get();
+        query.ForEach(data, handler, ParallelRunner.Default, barrier);
+        barrier.WaitAndReturn();
+    }
     
     #endregion // ParallelRunner
 
@@ -98,7 +114,7 @@ public static unsafe void ForEachOnParallel<TData>(
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public unsafe static void ForSlice<TRunner, C1>(
-        this IEntityQuery query, ComponentHandler<C1> handler, TRunner runner)
+        this IEntityQuery query, ComponentHandler<C1> handler, TRunner runner, RunnerBarrier? barrier)
         where TRunner : IRunner
         => query.Handle(handler,
             static (IEntityHost host, in ComponentHandler<C1> handler, int from, int to) => {
@@ -111,11 +127,11 @@ public unsafe static void ForSlice<TRunner, C1>(
                     ref var byteRef = ref host.UnsafeGetByteRef(slots[i]);
                     handler(ref c1Offset.Get(ref byteRef));
                 }
-            }, runner);
+            }, runner, barrier);
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public unsafe static void ForSlice<TRunner, C1, C2>(
-        this IEntityQuery query, ComponentHandler<C1, C2> handler, TRunner runner)
+        this IEntityQuery query, ComponentHandler<C1, C2> handler, TRunner runner, RunnerBarrier? barrier)
         where TRunner : IRunner
         => query.Handle(handler,
             static (IEntityHost host, in ComponentHandler<C1, C2> handler, int from, int to) => {
@@ -131,11 +147,11 @@ public unsafe static void ForSlice<TRunner, C1, C2>(
                         ref c1Offset.Get(ref byteRef),
                         ref c2Offset.Get(ref byteRef));
                 }
-            }, runner);
+            }, runner, barrier);
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public unsafe static void ForSlice<TRunner, C1, C2, C3>(
-        this IEntityQuery query, ComponentHandler<C1, C2, C3> handler, TRunner runner)
+        this IEntityQuery query, ComponentHandler<C1, C2, C3> handler, TRunner runner, RunnerBarrier? barrier)
         where TRunner : IRunner
         => query.Handle(handler,
             static (IEntityHost host, in ComponentHandler<C1, C2, C3> handler, int from, int to) => {
@@ -153,11 +169,11 @@ ref c1Offset.Get(ref byteRef),
                         ref c2Offset.Get(ref byteRef),
                         ref c3Offset.Get(ref byteRef));
                 }
-            }, runner);
+            }, runner, barrier);
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public unsafe static void ForSlice<TRunner, C1, C2, C3, C4>(
-        this IEntityQuery query, ComponentHandler<C1, C2, C3, C4> handler, TRunner runner)
+        this IEntityQuery query, ComponentHandler<C1, C2, C3, C4> handler, TRunner runner, RunnerBarrier? barrier)
         where TRunner : IRunner
         => query.Handle(handler,
             static (IEntityHost host, in ComponentHandler<C1, C2, C3, C4> handler, int from, int to) => {
@@ -177,11 +193,11 @@ ref c2Offset.Get(ref byteRef),
                         ref c3Offset.Get(ref byteRef),
                         ref c4Offset.Get(ref byteRef));
                 }
-            }, runner);
+            }, runner, barrier);
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public unsafe static void ForSlice<TRunner, C1, C2, C3, C4, C5>(
-        this IEntityQuery query, ComponentHandler<C1, C2, C3, C4, C5> handler, TRunner runner)
+        this IEntityQuery query, ComponentHandler<C1, C2, C3, C4, C5> handler, TRunner runner, RunnerBarrier? barrier)
         where TRunner : IRunner
         => query.Handle(handler,
             static (IEntityHost host, in ComponentHandler<C1, C2, C3, C4, C5> handler, int from, int to) => {
@@ -203,11 +219,11 @@ ref c3Offset.Get(ref byteRef),
                         ref c4Offset.Get(ref byteRef),
                         ref c5Offset.Get(ref byteRef));
                 }
-            }, runner);
+            }, runner, barrier);
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public unsafe static void ForSlice<TRunner, C1, C2, C3, C4, C5, C6>(
-        this IEntityQuery query, ComponentHandler<C1, C2, C3, C4, C5, C6> handler, TRunner runner)
+        this IEntityQuery query, ComponentHandler<C1, C2, C3, C4, C5, C6> handler, TRunner runner, RunnerBarrier? barrier)
         where TRunner : IRunner
         => query.Handle(handler,
             static (IEntityHost host, in ComponentHandler<C1, C2, C3, C4, C5, C6> handler, int from, int to) => {
@@ -231,11 +247,11 @@ ref c4Offset.Get(ref byteRef),
                         ref c5Offset.Get(ref byteRef),
                         ref c6Offset.Get(ref byteRef));
                 }
-            }, runner);
+            }, runner, barrier);
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public unsafe static void ForSlice<TRunner, TData, C1>(
-        this IEntityQuery query, in TData userData, DataComponentHandler<TData, C1> handler, TRunner runner)
+        this IEntityQuery query, in TData userData, DataComponentHandler<TData, C1> handler, TRunner runner, RunnerBarrier? barrier)
         where TRunner : IRunner
         => query.Handle((handler, userData),
             static (IEntityHost host, in (DataComponentHandler<TData, C1>, TData) data, int from, int to) => {
@@ -251,11 +267,11 @@ public unsafe static void ForSlice<TRunner, TData, C1>(
                     ref var byteRef = ref host.UnsafeGetByteRef(slots[i]);
                     handler(userData, ref c1Offset.Get(ref byteRef));
                 }
-            }, runner);
+            }, runner, barrier);
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public unsafe static void ForSlice<TRunner, TData, C1, C2>(
-        this IEntityQuery query, in TData userData, DataComponentHandler<TData, C1, C2> handler, TRunner runner)
+        this IEntityQuery query, in TData userData, DataComponentHandler<TData, C1, C2> handler, TRunner runner, RunnerBarrier? barrier)
         where TRunner : IRunner
         => query.Handle((handler, userData),
             static (IEntityHost host, in (DataComponentHandler<TData, C1, C2>, TData) data, int from, int to) => {
@@ -274,11 +290,11 @@ public unsafe static void ForSlice<TRunner, TData, C1, C2>(
                         ref c1Offset.Get(ref byteRef),
                         ref c2Offset.Get(ref byteRef));
                 }
-            }, runner);
+            }, runner, barrier);
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public unsafe static void ForSlice<TRunner, TData, C1, C2, C3>(
-        this IEntityQuery query, in TData userData, DataComponentHandler<TData, C1, C2, C3> handler, TRunner runner)
+        this IEntityQuery query, in TData userData, DataComponentHandler<TData, C1, C2, C3> handler, TRunner runner, RunnerBarrier? barrier)
         where TRunner : IRunner
         => query.Handle((handler, userData),
             static (IEntityHost host, in (DataComponentHandler<TData, C1, C2, C3>, TData) data, int from, int to) => {
@@ -299,11 +315,11 @@ ref c1Offset.Get(ref byteRef),
                         ref c2Offset.Get(ref byteRef),
                         ref c3Offset.Get(ref byteRef));
                 }
-            }, runner);
+            }, runner, barrier);
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public unsafe static void ForSlice<TRunner, TData, C1, C2, C3, C4>(
-        this IEntityQuery query, in TData userData, DataComponentHandler<TData, C1, C2, C3, C4> handler, TRunner runner)
+        this IEntityQuery query, in TData userData, DataComponentHandler<TData, C1, C2, C3, C4> handler, TRunner runner, RunnerBarrier? barrier)
         where TRunner : IRunner
         => query.Handle((handler, userData),
             static (IEntityHost host, in (DataComponentHandler<TData, C1, C2, C3, C4>, TData) data, int from, int to) => {
@@ -326,11 +342,11 @@ ref c2Offset.Get(ref byteRef),
                         ref c3Offset.Get(ref byteRef),
                         ref c4Offset.Get(ref byteRef));
                 }
-            }, runner);
+            }, runner, barrier);
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public unsafe static void ForSlice<TRunner, TData, C1, C2, C3, C4, C5>(
-        this IEntityQuery query, in TData userData, DataComponentHandler<TData, C1, C2, C3, C4, C5> handler, TRunner runner)
+        this IEntityQuery query, in TData userData, DataComponentHandler<TData, C1, C2, C3, C4, C5> handler, TRunner runner, RunnerBarrier? barrier)
         where TRunner : IRunner
         => query.Handle((handler, userData),
             static (IEntityHost host, in (DataComponentHandler<TData, C1, C2, C3, C4, C5>, TData) data, int from, int to) => {
@@ -355,11 +371,11 @@ ref c3Offset.Get(ref byteRef),
                         ref c4Offset.Get(ref byteRef),
                         ref c5Offset.Get(ref byteRef));
                 }
-            }, runner);
+            }, runner, barrier);
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public unsafe static void ForSlice<TRunner, TData, C1, C2, C3, C4, C5, C6>(
-        this IEntityQuery query, in TData userData, DataComponentHandler<TData, C1, C2, C3, C4, C5, C6> handler, TRunner runner)
+        this IEntityQuery query, in TData userData, DataComponentHandler<TData, C1, C2, C3, C4, C5, C6> handler, TRunner runner, RunnerBarrier? barrier)
         where TRunner : IRunner
         => query.Handle((handler, userData),
             static (IEntityHost host, in (DataComponentHandler<TData, C1, C2, C3, C4, C5, C6>, TData) data, int from, int to) => {
@@ -386,133 +402,181 @@ ref c4Offset.Get(ref byteRef),
                         ref c5Offset.Get(ref byteRef),
                         ref c6Offset.Get(ref byteRef));
                 }
-            }, runner);
+            }, runner, barrier);
 
     #region CurrentThreadRunner
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public unsafe static void ForSlice<C1>(
         this IEntityQuery query, ComponentHandler<C1> handler)
-        => query.ForSlice(handler, CurrentThreadRunner.Instance);
+        => query.ForSlice(handler, CurrentThreadRunner.Instance, barrier: null);
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public unsafe static void ForSlice<C1, C2>(
         this IEntityQuery query, ComponentHandler<C1, C2> handler)
-        => query.ForSlice(handler, CurrentThreadRunner.Instance);
+        => query.ForSlice(handler, CurrentThreadRunner.Instance, barrier: null);
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public unsafe static void ForSlice<C1, C2, C3>(
         this IEntityQuery query, ComponentHandler<C1, C2, C3> handler)
-        => query.ForSlice(handler, CurrentThreadRunner.Instance);
+        => query.ForSlice(handler, CurrentThreadRunner.Instance, barrier: null);
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public unsafe static void ForSlice<C1, C2, C3, C4>(
         this IEntityQuery query, ComponentHandler<C1, C2, C3, C4> handler)
-        => query.ForSlice(handler, CurrentThreadRunner.Instance);
+        => query.ForSlice(handler, CurrentThreadRunner.Instance, barrier: null);
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public unsafe static void ForSlice<C1, C2, C3, C4, C5>(
         this IEntityQuery query, ComponentHandler<C1, C2, C3, C4, C5> handler)
-        => query.ForSlice(handler, CurrentThreadRunner.Instance);
+        => query.ForSlice(handler, CurrentThreadRunner.Instance, barrier: null);
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public unsafe static void ForSlice<C1, C2, C3, C4, C5, C6>(
         this IEntityQuery query, ComponentHandler<C1, C2, C3, C4, C5, C6> handler)
-        => query.ForSlice(handler, CurrentThreadRunner.Instance);
+        => query.ForSlice(handler, CurrentThreadRunner.Instance, barrier: null);
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public unsafe static void ForSlice<TData, C1>(
         this IEntityQuery query, in TData userData, DataComponentHandler<TData, C1> handler)
-        => query.ForSlice(userData, handler, CurrentThreadRunner.Instance);
+        => query.ForSlice(userData, handler, CurrentThreadRunner.Instance, barrier: null);
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public unsafe static void ForSlice<TData, C1, C2>(
         this IEntityQuery query, in TData userData, DataComponentHandler<TData, C1, C2> handler)
-        => query.ForSlice(userData, handler, CurrentThreadRunner.Instance);
+        => query.ForSlice(userData, handler, CurrentThreadRunner.Instance, barrier: null);
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public unsafe static void ForSlice<TData, C1, C2, C3>(
         this IEntityQuery query, in TData userData, DataComponentHandler<TData, C1, C2, C3> handler)
-        => query.ForSlice(userData, handler, CurrentThreadRunner.Instance);
+        => query.ForSlice(userData, handler, CurrentThreadRunner.Instance, barrier: null);
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public unsafe static void ForSlice<TData, C1, C2, C3, C4>(
         this IEntityQuery query, in TData userData, DataComponentHandler<TData, C1, C2, C3, C4> handler)
-        => query.ForSlice(userData, handler, CurrentThreadRunner.Instance);
+        => query.ForSlice(userData, handler, CurrentThreadRunner.Instance, barrier: null);
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public unsafe static void ForSlice<TData, C1, C2, C3, C4, C5>(
         this IEntityQuery query, in TData userData, DataComponentHandler<TData, C1, C2, C3, C4, C5> handler)
-        => query.ForSlice(userData, handler, CurrentThreadRunner.Instance);
+        => query.ForSlice(userData, handler, CurrentThreadRunner.Instance, barrier: null);
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public unsafe static void ForSlice<TData, C1, C2, C3, C4, C5, C6>(
         this IEntityQuery query, in TData userData, DataComponentHandler<TData, C1, C2, C3, C4, C5, C6> handler)
-        => query.ForSlice(userData, handler, CurrentThreadRunner.Instance);
+        => query.ForSlice(userData, handler, CurrentThreadRunner.Instance, barrier: null);
     
-    #endregion // ParallelRunner
+    #endregion // CurrentThreadRunner
 
     #region ParallelRunner
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public unsafe static void ForSliceOnParallel<C1>(
         this IEntityQuery query, ComponentHandler<C1> handler)
-        => query.ForSlice(handler, ParallelRunner.Default);
+    {
+        var barrier = RunnerBarrier.Get();
+        query.ForSlice(handler, ParallelRunner.Default, barrier);
+        barrier.WaitAndReturn();
+    }
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public unsafe static void ForSliceOnParallel<C1, C2>(
         this IEntityQuery query, ComponentHandler<C1, C2> handler)
-        => query.ForSlice(handler, ParallelRunner.Default);
+    {
+        var barrier = RunnerBarrier.Get();
+        query.ForSlice(handler, ParallelRunner.Default, barrier);
+        barrier.WaitAndReturn();
+    }
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public unsafe static void ForSliceOnParallel<C1, C2, C3>(
         this IEntityQuery query, ComponentHandler<C1, C2, C3> handler)
-        => query.ForSlice(handler, ParallelRunner.Default);
+    {
+        var barrier = RunnerBarrier.Get();
+        query.ForSlice(handler, ParallelRunner.Default, barrier);
+        barrier.WaitAndReturn();
+    }
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public unsafe static void ForSliceOnParallel<C1, C2, C3, C4>(
         this IEntityQuery query, ComponentHandler<C1, C2, C3, C4> handler)
-        => query.ForSlice(handler, ParallelRunner.Default);
+    {
+        var barrier = RunnerBarrier.Get();
+        query.ForSlice(handler, ParallelRunner.Default, barrier);
+        barrier.WaitAndReturn();
+    }
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public unsafe static void ForSliceOnParallel<C1, C2, C3, C4, C5>(
         this IEntityQuery query, ComponentHandler<C1, C2, C3, C4, C5> handler)
-        => query.ForSlice(handler, ParallelRunner.Default);
+    {
+        var barrier = RunnerBarrier.Get();
+        query.ForSlice(handler, ParallelRunner.Default, barrier);
+        barrier.WaitAndReturn();
+    }
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public unsafe static void ForSliceOnParallel<C1, C2, C3, C4, C5, C6>(
         this IEntityQuery query, ComponentHandler<C1, C2, C3, C4, C5, C6> handler)
-        => query.ForSlice(handler, ParallelRunner.Default);
+    {
+        var barrier = RunnerBarrier.Get();
+        query.ForSlice(handler, ParallelRunner.Default, barrier);
+        barrier.WaitAndReturn();
+    }
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public unsafe static void ForSliceOnParallel<TData, C1>(
         this IEntityQuery query, in TData userData, DataComponentHandler<TData, C1> handler)
-        => query.ForSlice(userData, handler, ParallelRunner.Default);
+    {
+        var barrier = RunnerBarrier.Get();
+        query.ForSlice(userData, handler, ParallelRunner.Default, barrier);
+        barrier.WaitAndReturn();
+    }
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public unsafe static void ForSliceOnParallel<TData, C1, C2>(
         this IEntityQuery query, in TData userData, DataComponentHandler<TData, C1, C2> handler)
-        => query.ForSlice(userData, handler, ParallelRunner.Default);
+    {
+        var barrier = RunnerBarrier.Get();
+        query.ForSlice(userData, handler, ParallelRunner.Default, barrier);
+        barrier.WaitAndReturn();
+    }
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public unsafe static void ForSliceOnParallel<TData, C1, C2, C3>(
         this IEntityQuery query, in TData userData, DataComponentHandler<TData, C1, C2, C3> handler)
-        => query.ForSlice(userData, handler, ParallelRunner.Default);
+    {
+        var barrier = RunnerBarrier.Get();
+        query.ForSlice(userData, handler, ParallelRunner.Default, barrier);
+        barrier.WaitAndReturn();
+    }
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public unsafe static void ForSliceOnParallel<TData, C1, C2, C3, C4>(
         this IEntityQuery query, in TData userData, DataComponentHandler<TData, C1, C2, C3, C4> handler)
-        => query.ForSlice(userData, handler, ParallelRunner.Default);
+    {
+        var barrier = RunnerBarrier.Get();
+        query.ForSlice(userData, handler, ParallelRunner.Default, barrier);
+        barrier.WaitAndReturn();
+    }
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public unsafe static void ForSliceOnParallel<TData, C1, C2, C3, C4, C5>(
         this IEntityQuery query, in TData userData, DataComponentHandler<TData, C1, C2, C3, C4, C5> handler)
-        => query.ForSlice(userData, handler, ParallelRunner.Default);
+    {
+        var barrier = RunnerBarrier.Get();
+        query.ForSlice(userData, handler, ParallelRunner.Default, barrier);
+        barrier.WaitAndReturn();
+    }
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public unsafe static void ForSliceOnParallel<TData, C1, C2, C3, C4, C5, C6>(
         this IEntityQuery query, in TData userData, DataComponentHandler<TData, C1, C2, C3, C4, C5, C6> handler)
-        => query.ForSlice(userData, handler, ParallelRunner.Default);
+    {
+        var barrier = RunnerBarrier.Get();
+        query.ForSlice(userData, handler, ParallelRunner.Default, barrier);
+        barrier.WaitAndReturn();
+    }
     
     #endregion // ParallelRunner
 
@@ -522,7 +586,7 @@ public unsafe static void ForSliceOnParallel<TData, C1, C2, C3, C4, C5, C6>(
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public unsafe static void Filter<TRunner, C1>(
-        this IEntityQuery query, ComponentFilter<C1> filter, EntityHandler handler, TRunner runner)
+        this IEntityQuery query, ComponentFilter<C1> filter, EntityHandler handler, TRunner runner, RunnerBarrier? barrier)
         where TRunner : IRunner
         => query.Handle((filter, handler),
             static (IEntityHost host, in (ComponentFilter<C1>, EntityHandler) fs, int from, int to) => {
@@ -540,11 +604,11 @@ public unsafe static void Filter<TRunner, C1>(
                         handler(new(slot, host));
                     }
                 }
-            }, runner);
+            }, runner, barrier);
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public unsafe static void Filter<TRunner, C1, C2>(
-        this IEntityQuery query, ComponentFilter<C1, C2> filter, EntityHandler handler, TRunner runner)
+        this IEntityQuery query, ComponentFilter<C1, C2> filter, EntityHandler handler, TRunner runner, RunnerBarrier? barrier)
         where TRunner : IRunner
         => query.Handle((filter, handler),
             static (IEntityHost host, in (ComponentFilter<C1, C2>, EntityHandler) fs, int from, int to) => {
@@ -565,11 +629,11 @@ ref c2Offset.Get(ref byteRef))) {
                         handler(new(slot, host));
                     }
                 }
-            }, runner);
+            }, runner, barrier);
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public unsafe static void Filter<TRunner, C1, C2, C3>(
-        this IEntityQuery query, ComponentFilter<C1, C2, C3> filter, EntityHandler handler, TRunner runner)
+        this IEntityQuery query, ComponentFilter<C1, C2, C3> filter, EntityHandler handler, TRunner runner, RunnerBarrier? barrier)
         where TRunner : IRunner
         => query.Handle((filter, handler),
             static (IEntityHost host, in (ComponentFilter<C1, C2, C3>, EntityHandler) fs, int from, int to) => {
@@ -592,11 +656,11 @@ ref c3Offset.Get(ref byteRef))) {
                         handler(new(slot, host));
                     }
                 }
-            }, runner);
+            }, runner, barrier);
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public unsafe static void Filter<TRunner, C1, C2, C3, C4>(
-        this IEntityQuery query, ComponentFilter<C1, C2, C3, C4> filter, EntityHandler handler, TRunner runner)
+        this IEntityQuery query, ComponentFilter<C1, C2, C3, C4> filter, EntityHandler handler, TRunner runner, RunnerBarrier? barrier)
         where TRunner : IRunner
         => query.Handle((filter, handler),
             static (IEntityHost host, in (ComponentFilter<C1, C2, C3, C4>, EntityHandler) fs, int from, int to) => {
@@ -621,11 +685,11 @@ ref c4Offset.Get(ref byteRef))) {
                         handler(new(slot, host));
                     }
                 }
-            }, runner);
+            }, runner, barrier);
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public unsafe static void Filter<TRunner, C1, C2, C3, C4, C5>(
-        this IEntityQuery query, ComponentFilter<C1, C2, C3, C4, C5> filter, EntityHandler handler, TRunner runner)
+        this IEntityQuery query, ComponentFilter<C1, C2, C3, C4, C5> filter, EntityHandler handler, TRunner runner, RunnerBarrier? barrier)
         where TRunner : IRunner
         => query.Handle((filter, handler),
             static (IEntityHost host, in (ComponentFilter<C1, C2, C3, C4, C5>, EntityHandler) fs, int from, int to) => {
@@ -652,11 +716,11 @@ ref c5Offset.Get(ref byteRef))) {
                         handler(new(slot, host));
                     }
                 }
-            }, runner);
+            }, runner, barrier);
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public unsafe static void Filter<TRunner, C1, C2, C3, C4, C5, C6>(
-        this IEntityQuery query, ComponentFilter<C1, C2, C3, C4, C5, C6> filter, EntityHandler handler, TRunner runner)
+        this IEntityQuery query, ComponentFilter<C1, C2, C3, C4, C5, C6> filter, EntityHandler handler, TRunner runner, RunnerBarrier? barrier)
         where TRunner : IRunner
         => query.Handle((filter, handler),
             static (IEntityHost host, in (ComponentFilter<C1, C2, C3, C4, C5, C6>, EntityHandler) fs, int from, int to) => {
@@ -685,11 +749,11 @@ ref c6Offset.Get(ref byteRef))) {
                         handler(new(slot, host));
                     }
                 }
-            }, runner);
+            }, runner, barrier);
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public unsafe static void Filter<TRunner, TData, C1>(
-        this IEntityQuery query, in TData userData, DataComponentFilter<TData, C1> filter, EntityHandler<TData> handler, TRunner runner)
+        this IEntityQuery query, in TData userData, DataComponentFilter<TData, C1> filter, EntityHandler<TData> handler, TRunner runner, RunnerBarrier? barrier)
         where TRunner : IRunner
         => query.Handle((filter, handler, userData),
             static (IEntityHost host, in (DataComponentFilter<TData, C1>, EntityHandler<TData>, TData) data, int from, int to) => {
@@ -710,11 +774,11 @@ public unsafe static void Filter<TRunner, TData, C1>(
                         handler(userData, new(slot, host));
                     }
                 }
-            }, runner);
+            }, runner, barrier);
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public unsafe static void Filter<TRunner, TData, C1, C2>(
-        this IEntityQuery query, in TData userData, DataComponentFilter<TData, C1, C2> filter, EntityHandler<TData> handler, TRunner runner)
+        this IEntityQuery query, in TData userData, DataComponentFilter<TData, C1, C2> filter, EntityHandler<TData> handler, TRunner runner, RunnerBarrier? barrier)
         where TRunner : IRunner
         => query.Handle((filter, handler, userData),
             static (IEntityHost host, in (DataComponentFilter<TData, C1, C2>, EntityHandler<TData>, TData) data, int from, int to) => {
@@ -738,11 +802,11 @@ ref c2Offset.Get(ref byteRef))) {
                         handler(userData, new(slot, host));
                     }
                 }
-            }, runner);
+            }, runner, barrier);
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public unsafe static void Filter<TRunner, TData, C1, C2, C3>(
-        this IEntityQuery query, in TData userData, DataComponentFilter<TData, C1, C2, C3> filter, EntityHandler<TData> handler, TRunner runner)
+        this IEntityQuery query, in TData userData, DataComponentFilter<TData, C1, C2, C3> filter, EntityHandler<TData> handler, TRunner runner, RunnerBarrier? barrier)
         where TRunner : IRunner
         => query.Handle((filter, handler, userData),
             static (IEntityHost host, in (DataComponentFilter<TData, C1, C2, C3>, EntityHandler<TData>, TData) data, int from, int to) => {
@@ -768,11 +832,11 @@ ref c3Offset.Get(ref byteRef))) {
                         handler(userData, new(slot, host));
                     }
                 }
-            }, runner);
+            }, runner, barrier);
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public unsafe static void Filter<TRunner, TData, C1, C2, C3, C4>(
-        this IEntityQuery query, in TData userData, DataComponentFilter<TData, C1, C2, C3, C4> filter, EntityHandler<TData> handler, TRunner runner)
+        this IEntityQuery query, in TData userData, DataComponentFilter<TData, C1, C2, C3, C4> filter, EntityHandler<TData> handler, TRunner runner, RunnerBarrier? barrier)
         where TRunner : IRunner
         => query.Handle((filter, handler, userData),
             static (IEntityHost host, in (DataComponentFilter<TData, C1, C2, C3, C4>, EntityHandler<TData>, TData) data, int from, int to) => {
@@ -800,11 +864,11 @@ ref c4Offset.Get(ref byteRef))) {
                         handler(userData, new(slot, host));
                     }
                 }
-            }, runner);
+            }, runner, barrier);
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public unsafe static void Filter<TRunner, TData, C1, C2, C3, C4, C5>(
-        this IEntityQuery query, in TData userData, DataComponentFilter<TData, C1, C2, C3, C4, C5> filter, EntityHandler<TData> handler, TRunner runner)
+        this IEntityQuery query, in TData userData, DataComponentFilter<TData, C1, C2, C3, C4, C5> filter, EntityHandler<TData> handler, TRunner runner, RunnerBarrier? barrier)
         where TRunner : IRunner
         => query.Handle((filter, handler, userData),
             static (IEntityHost host, in (DataComponentFilter<TData, C1, C2, C3, C4, C5>, EntityHandler<TData>, TData) data, int from, int to) => {
@@ -834,11 +898,11 @@ ref c5Offset.Get(ref byteRef))) {
                         handler(userData, new(slot, host));
                     }
                 }
-            }, runner);
+            }, runner, barrier);
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public unsafe static void Filter<TRunner, TData, C1, C2, C3, C4, C5, C6>(
-        this IEntityQuery query, in TData userData, DataComponentFilter<TData, C1, C2, C3, C4, C5, C6> filter, EntityHandler<TData> handler, TRunner runner)
+        this IEntityQuery query, in TData userData, DataComponentFilter<TData, C1, C2, C3, C4, C5, C6> filter, EntityHandler<TData> handler, TRunner runner, RunnerBarrier? barrier)
         where TRunner : IRunner
         => query.Handle((filter, handler, userData),
             static (IEntityHost host, in (DataComponentFilter<TData, C1, C2, C3, C4, C5, C6>, EntityHandler<TData>, TData) data, int from, int to) => {
@@ -870,133 +934,181 @@ ref c6Offset.Get(ref byteRef))) {
                         handler(userData, new(slot, host));
                     }
                 }
-            }, runner);
+            }, runner, barrier);
 
     #region CurrentThreadRunner
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public unsafe static void Filter<C1>(
         this IEntityQuery query, ComponentFilter<C1> filter, EntityHandler handler)
-        => query.Filter(filter, handler, CurrentThreadRunner.Instance);
+        => query.Filter(filter, handler, CurrentThreadRunner.Instance, barrier: null);
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public unsafe static void Filter<C1, C2>(
         this IEntityQuery query, ComponentFilter<C1, C2> filter, EntityHandler handler)
-        => query.Filter(filter, handler, CurrentThreadRunner.Instance);
+        => query.Filter(filter, handler, CurrentThreadRunner.Instance, barrier: null);
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public unsafe static void Filter<C1, C2, C3>(
         this IEntityQuery query, ComponentFilter<C1, C2, C3> filter, EntityHandler handler)
-        => query.Filter(filter, handler, CurrentThreadRunner.Instance);
+        => query.Filter(filter, handler, CurrentThreadRunner.Instance, barrier: null);
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public unsafe static void Filter<C1, C2, C3, C4>(
         this IEntityQuery query, ComponentFilter<C1, C2, C3, C4> filter, EntityHandler handler)
-        => query.Filter(filter, handler, CurrentThreadRunner.Instance);
+        => query.Filter(filter, handler, CurrentThreadRunner.Instance, barrier: null);
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public unsafe static void Filter<C1, C2, C3, C4, C5>(
         this IEntityQuery query, ComponentFilter<C1, C2, C3, C4, C5> filter, EntityHandler handler)
-        => query.Filter(filter, handler, CurrentThreadRunner.Instance);
+        => query.Filter(filter, handler, CurrentThreadRunner.Instance, barrier: null);
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public unsafe static void Filter<C1, C2, C3, C4, C5, C6>(
         this IEntityQuery query, ComponentFilter<C1, C2, C3, C4, C5, C6> filter, EntityHandler handler)
-        => query.Filter(filter, handler, CurrentThreadRunner.Instance);
+        => query.Filter(filter, handler, CurrentThreadRunner.Instance, barrier: null);
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public unsafe static void Filter<TData, C1>(
         this IEntityQuery query, in TData userData, DataComponentFilter<TData, C1> filter, EntityHandler<TData> handler)
-        => query.Filter(userData, filter, handler, CurrentThreadRunner.Instance);
+        => query.Filter(userData, filter, handler, CurrentThreadRunner.Instance, barrier: null);
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public unsafe static void Filter<TData, C1, C2>(
         this IEntityQuery query, in TData userData, DataComponentFilter<TData, C1, C2> filter, EntityHandler<TData> handler)
-        => query.Filter(userData, filter, handler, CurrentThreadRunner.Instance);
+        => query.Filter(userData, filter, handler, CurrentThreadRunner.Instance, barrier: null);
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public unsafe static void Filter<TData, C1, C2, C3>(
         this IEntityQuery query, in TData userData, DataComponentFilter<TData, C1, C2, C3> filter, EntityHandler<TData> handler)
-        => query.Filter(userData, filter, handler, CurrentThreadRunner.Instance);
+        => query.Filter(userData, filter, handler, CurrentThreadRunner.Instance, barrier: null);
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public unsafe static void Filter<TData, C1, C2, C3, C4>(
         this IEntityQuery query, in TData userData, DataComponentFilter<TData, C1, C2, C3, C4> filter, EntityHandler<TData> handler)
-        => query.Filter(userData, filter, handler, CurrentThreadRunner.Instance);
+        => query.Filter(userData, filter, handler, CurrentThreadRunner.Instance, barrier: null);
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public unsafe static void Filter<TData, C1, C2, C3, C4, C5>(
         this IEntityQuery query, in TData userData, DataComponentFilter<TData, C1, C2, C3, C4, C5> filter, EntityHandler<TData> handler)
-        => query.Filter(userData, filter, handler, CurrentThreadRunner.Instance);
+        => query.Filter(userData, filter, handler, CurrentThreadRunner.Instance, barrier: null);
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public unsafe static void Filter<TData, C1, C2, C3, C4, C5, C6>(
         this IEntityQuery query, in TData userData, DataComponentFilter<TData, C1, C2, C3, C4, C5, C6> filter, EntityHandler<TData> handler)
-        => query.Filter(userData, filter, handler, CurrentThreadRunner.Instance);
+        => query.Filter(userData, filter, handler, CurrentThreadRunner.Instance, barrier: null);
     
-    #endregion // ParallelRunner
+    #endregion // CurrentThreadRunner
 
     #region ParallelRunner
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public unsafe static void FilterOnParallel<C1>(
         this IEntityQuery query, ComponentFilter<C1> filter, EntityHandler handler)
-        => query.Filter(filter, handler, ParallelRunner.Default);
+    {
+        var barrier = RunnerBarrier.Get();
+        query.Filter(filter, handler, ParallelRunner.Default, barrier);
+        barrier.WaitAndReturn();
+    }
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public unsafe static void FilterOnParallel<C1, C2>(
         this IEntityQuery query, ComponentFilter<C1, C2> filter, EntityHandler handler)
-        => query.Filter(filter, handler, ParallelRunner.Default);
+    {
+        var barrier = RunnerBarrier.Get();
+        query.Filter(filter, handler, ParallelRunner.Default, barrier);
+        barrier.WaitAndReturn();
+    }
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public unsafe static void FilterOnParallel<C1, C2, C3>(
         this IEntityQuery query, ComponentFilter<C1, C2, C3> filter, EntityHandler handler)
-        => query.Filter(filter, handler, ParallelRunner.Default);
+    {
+        var barrier = RunnerBarrier.Get();
+        query.Filter(filter, handler, ParallelRunner.Default, barrier);
+        barrier.WaitAndReturn();
+    }
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public unsafe static void FilterOnParallel<C1, C2, C3, C4>(
         this IEntityQuery query, ComponentFilter<C1, C2, C3, C4> filter, EntityHandler handler)
-        => query.Filter(filter, handler, ParallelRunner.Default);
+    {
+        var barrier = RunnerBarrier.Get();
+        query.Filter(filter, handler, ParallelRunner.Default, barrier);
+        barrier.WaitAndReturn();
+    }
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public unsafe static void FilterOnParallel<C1, C2, C3, C4, C5>(
         this IEntityQuery query, ComponentFilter<C1, C2, C3, C4, C5> filter, EntityHandler handler)
-        => query.Filter(filter, handler, ParallelRunner.Default);
+    {
+        var barrier = RunnerBarrier.Get();
+        query.Filter(filter, handler, ParallelRunner.Default, barrier);
+        barrier.WaitAndReturn();
+    }
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public unsafe static void FilterOnParallel<C1, C2, C3, C4, C5, C6>(
         this IEntityQuery query, ComponentFilter<C1, C2, C3, C4, C5, C6> filter, EntityHandler handler)
-        => query.Filter(filter, handler, ParallelRunner.Default);
+    {
+        var barrier = RunnerBarrier.Get();
+        query.Filter(filter, handler, ParallelRunner.Default, barrier);
+        barrier.WaitAndReturn();
+    }
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public unsafe static void FilterOnParallel<TData, C1>(
         this IEntityQuery query, in TData userData, DataComponentFilter<TData, C1> filter, EntityHandler<TData> handler)
-        => query.Filter(userData, filter, handler, ParallelRunner.Default);
+    {
+        var barrier = RunnerBarrier.Get();
+        query.Filter(userData, filter, handler, ParallelRunner.Default, barrier);
+        barrier.WaitAndReturn();
+    }
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public unsafe static void FilterOnParallel<TData, C1, C2>(
         this IEntityQuery query, in TData userData, DataComponentFilter<TData, C1, C2> filter, EntityHandler<TData> handler)
-        => query.Filter(userData, filter, handler, ParallelRunner.Default);
+    {
+        var barrier = RunnerBarrier.Get();
+        query.Filter(userData, filter, handler, ParallelRunner.Default, barrier);
+        barrier.WaitAndReturn();
+    }
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public unsafe static void FilterOnParallel<TData, C1, C2, C3>(
         this IEntityQuery query, in TData userData, DataComponentFilter<TData, C1, C2, C3> filter, EntityHandler<TData> handler)
-        => query.Filter(userData, filter, handler, ParallelRunner.Default);
+    {
+        var barrier = RunnerBarrier.Get();
+        query.Filter(userData, filter, handler, ParallelRunner.Default, barrier);
+        barrier.WaitAndReturn();
+    }
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public unsafe static void FilterOnParallel<TData, C1, C2, C3, C4>(
         this IEntityQuery query, in TData userData, DataComponentFilter<TData, C1, C2, C3, C4> filter, EntityHandler<TData> handler)
-        => query.Filter(userData, filter, handler, ParallelRunner.Default);
+    {
+        var barrier = RunnerBarrier.Get();
+        query.Filter(userData, filter, handler, ParallelRunner.Default, barrier);
+        barrier.WaitAndReturn();
+    }
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public unsafe static void FilterOnParallel<TData, C1, C2, C3, C4, C5>(
         this IEntityQuery query, in TData userData, DataComponentFilter<TData, C1, C2, C3, C4, C5> filter, EntityHandler<TData> handler)
-        => query.Filter(userData, filter, handler, ParallelRunner.Default);
+    {
+        var barrier = RunnerBarrier.Get();
+        query.Filter(userData, filter, handler, ParallelRunner.Default, barrier);
+        barrier.WaitAndReturn();
+    }
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public unsafe static void FilterOnParallel<TData, C1, C2, C3, C4, C5, C6>(
         this IEntityQuery query, in TData userData, DataComponentFilter<TData, C1, C2, C3, C4, C5, C6> filter, EntityHandler<TData> handler)
-        => query.Filter(userData, filter, handler, ParallelRunner.Default);
+    {
+        var barrier = RunnerBarrier.Get();
+        query.Filter(userData, filter, handler, ParallelRunner.Default, barrier);
+        barrier.WaitAndReturn();
+    }
     
     #endregion // ParallelRunner
 
diff --git a/Sia/Entities/Extensions/EntityQueryExtensions.Handle.cs b/Sia/Entities/Extensions/EntityQueryExtensions.Handle.cs
index 6ef3c4b..63a164e 100644
--- a/Sia/Entities/Extensions/EntityQueryExtensions.Handle.cs
+++ b/Sia/Entities/Extensions/EntityQueryExtensions.Handle.cs
@@ -30,7 +30,7 @@ private static (IEntityHost Host, int HostIndex, int SlotIndex) FindHost(
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static unsafe void Handle<TRunner>(
-        this IEntityQuery query, EntityHostRangeHandler handler, TRunner runner, RunnerBarrier barrier)
+        this IEntityQuery query, EntityHostRangeHandler handler, TRunner runner, RunnerBarrier? barrier)
         where TRunner : IRunner
     {
         var count = query.Count;
@@ -66,20 +66,10 @@ static void Action(in HandleData data, (int, int) range)
         runner.Run(count, new HandleData(query, handler), Action, barrier);
     }
 
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static unsafe void Handle<TRunner>(
-        this IEntityQuery query, EntityHostRangeHandler handler, TRunner runner)
-        where TRunner : IRunner
-    {
-        var barrier = RunnerBarrier.Get();
-        query.Handle(handler, runner, barrier);
-        barrier.WaitAndReturn();
-    }
-
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static unsafe void Handle<TRunner, TData>(
         this IEntityQuery query, in TData userData, EntityHostRangeHandler<TData> handler,
-        TRunner runner, RunnerBarrier barrier)
+        TRunner runner, RunnerBarrier? barrier)
         where TRunner : IRunner
     {
         var count = query.Count;
@@ -125,27 +115,17 @@ static void Action(in HandleData<TData> data, (int, int) range)
         runner.Run(count, data, Action, barrier);
     }
 
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static unsafe void Handle<TRunner, TData>(
-        this IEntityQuery query, in TData userData, EntityHostRangeHandler<TData> handler, TRunner runner)
-        where TRunner : IRunner
-    {
-        var barrier = RunnerBarrier.Get();
-        query.Handle(userData, handler, runner, barrier);
-        barrier.WaitAndReturn();
-    }
-
     #region CurrentThreadRunner
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static unsafe void Handle(
         this IEntityQuery query, EntityHostRangeHandler handler)
-        => query.Handle(handler, CurrentThreadRunner.Instance);
+        => query.Handle(handler, CurrentThreadRunner.Instance, barrier: null);
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static unsafe void Handle<TData>(
         this IEntityQuery query, in TData data, EntityHostRangeHandler<TData> handler)
-        => query.Handle(data, handler, CurrentThreadRunner.Instance);
+        => query.Handle(data, handler, CurrentThreadRunner.Instance, barrier: null);
 
     #endregion // CurrentThreadRunner
 
@@ -154,12 +134,20 @@ public static unsafe void Handle<TData>(
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static unsafe void HandleOnParallel(
         this IEntityQuery query, EntityHostRangeHandler handler)
-        => query.Handle(handler, ParallelRunner.Default);
+    {
+        var barrier = RunnerBarrier.Get();
+        query.Handle(handler, ParallelRunner.Default, barrier);
+        barrier.WaitAndReturn();
+    }
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static unsafe void HandleOnParallel<TData>(
         this IEntityQuery query, in TData data, EntityHostRangeHandler<TData> handler)
-        => query.Handle(data, handler, ParallelRunner.Default);
+    {
+        var barrier = RunnerBarrier.Get();
+        query.Handle(data, handler, ParallelRunner.Default, barrier);
+        barrier.WaitAndReturn();
+    }
     
     #endregion // ParallelRunner
 }
\ No newline at end of file
diff --git a/Sia/Entities/Extensions/EntityQueryExtensions.Record.cs b/Sia/Entities/Extensions/EntityQueryExtensions.Record.cs
index 8480f77..74b6dc5 100644
--- a/Sia/Entities/Extensions/EntityQueryExtensions.Record.cs
+++ b/Sia/Entities/Extensions/EntityQueryExtensions.Record.cs
@@ -9,9 +9,10 @@ public static partial class EntityQueryExtensions
     #region EntityRecorder
 
     public unsafe static void Record<TRunner, TResult>(
-        this IEntityQuery query, Span<TResult> span, EntityRecorder<TResult> recorder, TRunner runner)
+        this IEntityQuery query, Span<TResult> span, EntityRecorder<TResult> recorder, TRunner runner, RunnerBarrier? barrier)
         where TRunner : IRunner
     {
+        GuardSpanLength(span, query.Count);
         int index = -1;
 
         fixed (TResult* pointer = span) {
@@ -32,14 +33,15 @@ public unsafe static void Record<TRunner, TResult>(
                         recorder(new(slots[i], host),
                             out *(pointer + Interlocked.Increment(ref index)));
                     }
-                }, runner);
+                }, runner, barrier);
         }
     }
 
     public unsafe static void Record<TRunner, TData, TResult>(
-        this IEntityQuery query, Span<TResult> span, in TData userData, EntityRecorder<TData, TResult> recorder, TRunner runner)
+        this IEntityQuery query, Span<TResult> span, in TData userData, EntityRecorder<TData, TResult> recorder, TRunner runner, RunnerBarrier? barrier)
         where TRunner : IRunner
     {
+        GuardSpanLength(span, query.Count);
         int index = -1;
 
         fixed (TResult* pointer = span) {
@@ -61,7 +63,7 @@ public unsafe static void Record<TRunner, TData, TResult>(
                         recorder(userData, new(slots[i], host),
                             out *(pointer + Interlocked.Increment(ref index)));
                     }
-                }, runner);
+                }, runner, barrier);
         }
     }
 
@@ -69,23 +71,23 @@ private static void IdEntityRecorder(in EntityRef entity, out EntityRef result)
         => result = entity;
 
     public unsafe static void Record<TRunner>(
-        this IEntityQuery query, Span<EntityRef> span, TRunner runner)
+        this IEntityQuery query, Span<EntityRef> span, TRunner runner, RunnerBarrier? barrier)
         where TRunner : IRunner
-        => query.Record(span, IdEntityRecorder, runner);
+        => query.Record(span, IdEntityRecorder, runner, barrier);
 
     #region CurrentThreadRunner
 
     public unsafe static void Record<TResult>(
         this IEntityQuery query, Span<TResult> span, EntityRecorder<TResult> recorder)
-        => query.Record(span, recorder, CurrentThreadRunner.Instance);
+        => query.Record(span, recorder, CurrentThreadRunner.Instance, barrier: null);
 
     public unsafe static void Record<TData, TResult>(
         this IEntityQuery query, Span<TResult> span, in TData userData, EntityRecorder<TData, TResult> recorder)
-        => query.Record(span, userData, recorder, CurrentThreadRunner.Instance);
+        => query.Record(span, userData, recorder, CurrentThreadRunner.Instance, barrier: null);
 
     public unsafe static void Record(
         this IEntityQuery query, Span<EntityRef> span)
-        => query.Record(span, IdEntityRecorder, CurrentThreadRunner.Instance);
+        => query.Record(span, IdEntityRecorder, CurrentThreadRunner.Instance, barrier: null);
 
     #endregion // CurrentThreadRunner
     
@@ -93,15 +95,27 @@ public unsafe static void Record(
 
     public unsafe static void RecordOnParallel<TResult>(
         this IEntityQuery query, Span<TResult> span, EntityRecorder<TResult> recorder)
-        => query.Record(span, recorder, ParallelRunner.Default);
+    {
+        var barrier = RunnerBarrier.Get();
+        query.Record(span, recorder, ParallelRunner.Default, barrier);
+        barrier.WaitAndReturn();
+    }
 
     public unsafe static void RecordOnParallel<TData, TResult>(
         this IEntityQuery query, Span<TResult> span, in TData userData, EntityRecorder<TData, TResult> recorder)
-        => query.Record(span, userData, recorder, ParallelRunner.Default);
+    {
+        var barrier = RunnerBarrier.Get();
+        query.Record(span, userData, recorder, ParallelRunner.Default, barrier);
+        barrier.WaitAndReturn();
+    }
 
     public unsafe static void RecordOnParallel(
         this IEntityQuery query, Span<EntityRef> span)
-        => query.Record(span, IdEntityRecorder, ParallelRunner.Default);
+    {
+        var barrier = RunnerBarrier.Get();
+        query.Record(span, IdEntityRecorder, ParallelRunner.Default, barrier);
+        barrier.WaitAndReturn();
+    }
 
     #endregion // ParallelRunner
 
@@ -110,9 +124,10 @@ public unsafe static void RecordOnParallel(
     #region ComponentRecorder
 
     public unsafe static void RecordSlices<TRunner, C1, TResult>(
-        this IEntityQuery query, Span<TResult> span, ComponentRecorder<C1, TResult> recorder, TRunner runner)
+        this IEntityQuery query, Span<TResult> span, ComponentRecorder<C1, TResult> recorder, TRunner runner, RunnerBarrier? barrier)
         where TRunner : IRunner
     {
+        GuardSpanLength(span, query.Count);
         int index = -1;
 
         fixed (TResult* pointer = span) {
@@ -126,14 +141,15 @@ public unsafe static void RecordSlices<TRunner, C1, TResult>(
                 static (in CompRecordData<C1, TResult> data, ref C1 c1) => {
                     data.Recorder(ref c1,
                         out *(data.Pointer + Interlocked.Increment(ref *data.Index)));
-                }, runner);
+                }, runner, barrier);
         }
     }
 
     public unsafe static void RecordSlices<TRunner, C1, C2, TResult>(
-        this IEntityQuery query, Span<TResult> span, ComponentRecorder<C1, C2, TResult> recorder, TRunner runner)
+        this IEntityQuery query, Span<TResult> span, ComponentRecorder<C1, C2, TResult> recorder, TRunner runner, RunnerBarrier? barrier)
         where TRunner : IRunner
     {
+        GuardSpanLength(span, query.Count);
         int index = -1;
 
         fixed (TResult* pointer = span) {
@@ -147,14 +163,15 @@ public unsafe static void RecordSlices<TRunner, C1, C2, TResult>(
                 static (in CompRecordData<C1, C2, TResult> data, ref C1 c1, ref C2 c2) => {
                     data.Recorder(ref c1, ref c2,
                         out *(data.Pointer + Interlocked.Increment(ref *data.Index)));
-                }, runner);
+                }, runner, barrier);
         }
     }
 
     public unsafe static void RecordSlices<TRunner, C1, C2, C3, TResult>(
-        this IEntityQuery query, Span<TResult> span, ComponentRecorder<C1, C2, C3, TResult> recorder, TRunner runner)
+        this IEntityQuery query, Span<TResult> span, ComponentRecorder<C1, C2, C3, TResult> recorder, TRunner runner, RunnerBarrier? barrier)
         where TRunner : IRunner
     {
+        GuardSpanLength(span, query.Count);
         int index = -1;
 
         fixed (TResult* pointer = span) {
@@ -168,14 +185,15 @@ public unsafe static void RecordSlices<TRunner, C1, C2, C3, TResult>(
                 static (in CompRecordData<C1, C2, C3, TResult> data, ref C1 c1, ref C2 c2, ref C3 c3) => {
                     data.Recorder(ref c1, ref c2, ref c3,
                         out *(data.Pointer + Interlocked.Increment(ref *data.Index)));
-                }, runner);
+                }, runner, barrier);
         }
     }
 
     public unsafe static void RecordSlices<TRunner, C1, C2, C3, C4, TResult>(
-        this IEntityQuery query, Span<TResult> span, ComponentRecorder<C1, C2, C3, C4, TResult> recorder, TRunner runner)
+        this IEntityQuery query, Span<TResult> span, ComponentRecorder<C1, C2, C3, C4, TResult> recorder, TRunner runner, RunnerBarrier? barrier)
         where TRunner : IRunner
     {
+        GuardSpanLength(span, query.Count);
         int index = -1;
 
         fixed (TResult* pointer = span) {
@@ -189,14 +207,15 @@ public unsafe static void RecordSlices<TRunner, C1, C2, C3, C4, TResult>(
                 static (in CompRecordData<C1, C2, C3, C4, TResult> data, ref C1 c1, ref C2 c2, ref C3 c3, ref C4 c4) => {
                     data.Recorder(ref c1, ref c2, ref c3, ref c4,
                         out *(data.Pointer + Interlocked.Increment(ref *data.Index)));
-                }, runner);
+                }, runner, barrier);
         }
     }
 
     public unsafe static void RecordSlices<TRunner, C1, C2, C3, C4, C5, TResult>(
-        this IEntityQuery query, Span<TResult> span, ComponentRecorder<C1, C2, C3, C4, C5, TResult> recorder, TRunner runner)
+        this IEntityQuery query, Span<TResult> span, ComponentRecorder<C1, C2, C3, C4, C5, TResult> recorder, TRunner runner, RunnerBarrier? barrier)
         where TRunner : IRunner
     {
+        GuardSpanLength(span, query.Count);
         int index = -1;
 
         fixed (TResult* pointer = span) {
@@ -210,14 +229,15 @@ public unsafe static void RecordSlices<TRunner, C1, C2, C3, C4, C5, TResult>(
                 static (in CompRecordData<C1, C2, C3, C4, C5, TResult> data, ref C1 c1, ref C2 c2, ref C3 c3, ref C4 c4, ref C5 c5) => {
                     data.Recorder(ref c1, ref c2, ref c3, ref c4, ref c5,
                         out *(data.Pointer + Interlocked.Increment(ref *data.Index)));
-                }, runner);
+                }, runner, barrier);
         }
     }
 
     public unsafe static void RecordSlices<TRunner, C1, C2, C3, C4, C5, C6, TResult>(
-        this IEntityQuery query, Span<TResult> span, ComponentRecorder<C1, C2, C3, C4, C5, C6, TResult> recorder, TRunner runner)
+        this IEntityQuery query, Span<TResult> span, ComponentRecorder<C1, C2, C3, C4, C5, C6, TResult> recorder, TRunner runner, RunnerBarrier? barrier)
         where TRunner : IRunner
     {
+        GuardSpanLength(span, query.Count);
         int index = -1;
 
         fixed (TResult* pointer = span) {
@@ -231,14 +251,15 @@ public unsafe static void RecordSlices<TRunner, C1, C2, C3, C4, C5, C6, TResult>
                 static (in CompRecordData<C1, C2, C3, C4, C5, C6, TResult> data, ref C1 c1, ref C2 c2, ref C3 c3, ref C4 c4, ref C5 c5, ref C6 c6) => {
                     data.Recorder(ref c1, ref c2, ref c3, ref c4, ref c5, ref c6,
                         out *(data.Pointer + Interlocked.Increment(ref *data.Index)));
-                }, runner);
+                }, runner, barrier);
         }
     }
 
     public unsafe static void RecordSlices<TRunner, TData, C1, TResult>(
-        this IEntityQuery query, Span<TResult> span, in TData userData, DataComponentRecorder<TData, C1, TResult> recorder, TRunner runner)
+        this IEntityQuery query, Span<TResult> span, in TData userData, DataComponentRecorder<TData, C1, TResult> recorder, TRunner runner, RunnerBarrier? barrier)
         where TRunner : IRunner
     {
+        GuardSpanLength(span, query.Count);
         int index = -1;
 
         fixed (TResult* pointer = span) {
@@ -254,14 +275,15 @@ public unsafe static void RecordSlices<TRunner, TData, C1, TResult>(
                     data.Recorder(data.UserData,
                         ref c1,
                         out *(data.Pointer + Interlocked.Increment(ref *data.Index)));
-                }, runner);
+                }, runner, barrier);
         }
     }
 
     public unsafe static void RecordSlices<TRunner, TData, C1, C2, TResult>(
-        this IEntityQuery query, Span<TResult> span, in TData userData, DataComponentRecorder<TData, C1, C2, TResult> recorder, TRunner runner)
+        this IEntityQuery query, Span<TResult> span, in TData userData, DataComponentRecorder<TData, C1, C2, TResult> recorder, TRunner runner, RunnerBarrier? barrier)
         where TRunner : IRunner
     {
+        GuardSpanLength(span, query.Count);
         int index = -1;
 
         fixed (TResult* pointer = span) {
@@ -277,14 +299,15 @@ public unsafe static void RecordSlices<TRunner, TData, C1, C2, TResult>(
                     data.Recorder(data.UserData,
                         ref c1, ref c2,
                         out *(data.Pointer + Interlocked.Increment(ref *data.Index)));
-                }, runner);
+                }, runner, barrier);
         }
     }
 
     public unsafe static void RecordSlices<TRunner, TData, C1, C2, C3, TResult>(
-        this IEntityQuery query, Span<TResult> span, in TData userData, DataComponentRecorder<TData, C1, C2, C3, TResult> recorder, TRunner runner)
+        this IEntityQuery query, Span<TResult> span, in TData userData, DataComponentRecorder<TData, C1, C2, C3, TResult> recorder, TRunner runner, RunnerBarrier? barrier)
         where TRunner : IRunner
     {
+        GuardSpanLength(span, query.Count);
         int index = -1;
 
         fixed (TResult* pointer = span) {
@@ -300,14 +323,15 @@ public unsafe static void RecordSlices<TRunner, TData, C1, C2, C3, TResult>(
                     data.Recorder(data.UserData,
                         ref c1, ref c2, ref c3,
                         out *(data.Pointer + Interlocked.Increment(ref *data.Index)));
-                }, runner);
+                }, runner, barrier);
         }
     }
 
     public unsafe static void RecordSlices<TRunner, TData, C1, C2, C3, C4, TResult>(
-        this IEntityQuery query, Span<TResult> span, in TData userData, DataComponentRecorder<TData, C1, C2, C3, C4, TResult> recorder, TRunner runner)
+        this IEntityQuery query, Span<TResult> span, in TData userData, DataComponentRecorder<TData, C1, C2, C3, C4, TResult> recorder, TRunner runner, RunnerBarrier? barrier)
         where TRunner : IRunner
     {
+        GuardSpanLength(span, query.Count);
         int index = -1;
 
         fixed (TResult* pointer = span) {
@@ -323,14 +347,15 @@ public unsafe static void RecordSlices<TRunner, TData, C1, C2, C3, C4, TResult>(
                     data.Recorder(data.UserData,
                         ref c1, ref c2, ref c3, ref c4,
                         out *(data.Pointer + Interlocked.Increment(ref *data.Index)));
-                }, runner);
+                }, runner, barrier);
         }
     }
 
     public unsafe static void RecordSlices<TRunner, TData, C1, C2, C3, C4, C5, TResult>(
-        this IEntityQuery query, Span<TResult> span, in TData userData, DataComponentRecorder<TData, C1, C2, C3, C4, C5, TResult> recorder, TRunner runner)
+        this IEntityQuery query, Span<TResult> span, in TData userData, DataComponentRecorder<TData, C1, C2, C3, C4, C5, TResult> recorder, TRunner runner, RunnerBarrier? barrier)
         where TRunner : IRunner
     {
+        GuardSpanLength(span, query.Count);
         int index = -1;
 
         fixed (TResult* pointer = span) {
@@ -346,14 +371,15 @@ public unsafe static void RecordSlices<TRunner, TData, C1, C2, C3, C4, C5, TResu
                     data.Recorder(data.UserData,
                         ref c1, ref c2, ref c3, ref c4, ref c5,
                         out *(data.Pointer + Interlocked.Increment(ref *data.Index)));
-                }, runner);
+                }, runner, barrier);
         }
     }
 
     public unsafe static void RecordSlices<TRunner, TData, C1, C2, C3, C4, C5, C6, TResult>(
-        this IEntityQuery query, Span<TResult> span, in TData userData, DataComponentRecorder<TData, C1, C2, C3, C4, C5, C6, TResult> recorder, TRunner runner)
+        this IEntityQuery query, Span<TResult> span, in TData userData, DataComponentRecorder<TData, C1, C2, C3, C4, C5, C6, TResult> recorder, TRunner runner, RunnerBarrier? barrier)
         where TRunner : IRunner
     {
+        GuardSpanLength(span, query.Count);
         int index = -1;
 
         fixed (TResult* pointer = span) {
@@ -369,7 +395,7 @@ public unsafe static void RecordSlices<TRunner, TData, C1, C2, C3, C4, C5, C6, T
                     data.Recorder(data.UserData,
                         ref c1, ref c2, ref c3, ref c4, ref c5, ref c6,
                         out *(data.Pointer + Interlocked.Increment(ref *data.Index)));
-                }, runner);
+                }, runner, barrier);
         }
     }
 
@@ -377,51 +403,51 @@ public unsafe static void RecordSlices<TRunner, TData, C1, C2, C3, C4, C5, C6, T
 
     public unsafe static void RecordSlices<C1, TResult>(
         this IEntityQuery query, Span<TResult> span, ComponentRecorder<C1, TResult> recorder)
-        => query.RecordSlices(span, recorder, CurrentThreadRunner.Instance);
+        => query.RecordSlices(span, recorder, CurrentThreadRunner.Instance, barrier: null);
 
     public unsafe static void RecordSlices<C1, C2, TResult>(
         this IEntityQuery query, Span<TResult> span, ComponentRecorder<C1, C2, TResult> recorder)
-        => query.RecordSlices(span, recorder, CurrentThreadRunner.Instance);
+        => query.RecordSlices(span, recorder, CurrentThreadRunner.Instance, barrier: null);
 
     public unsafe static void RecordSlices<C1, C2, C3, TResult>(
         this IEntityQuery query, Span<TResult> span, ComponentRecorder<C1, C2, C3, TResult> recorder)
-        => query.RecordSlices(span, recorder, CurrentThreadRunner.Instance);
+        => query.RecordSlices(span, recorder, CurrentThreadRunner.Instance, barrier: null);
 
     public unsafe static void RecordSlices<C1, C2, C3, C4, TResult>(
         this IEntityQuery query, Span<TResult> span, ComponentRecorder<C1, C2, C3, C4, TResult> recorder)
-        => query.RecordSlices(span, recorder, CurrentThreadRunner.Instance);
+        => query.RecordSlices(span, recorder, CurrentThreadRunner.Instance, barrier: null);
 
     public unsafe static void RecordSlices<C1, C2, C3, C4, C5, TResult>(
         this IEntityQuery query, Span<TResult> span, ComponentRecorder<C1, C2, C3, C4, C5, TResult> recorder)
-        => query.RecordSlices(span, recorder, CurrentThreadRunner.Instance);
+        => query.RecordSlices(span, recorder, CurrentThreadRunner.Instance, barrier: null);
 
     public unsafe static void RecordSlices<C1, C2, C3, C4, C5, C6, TResult>(
         this IEntityQuery query, Span<TResult> span, ComponentRecorder<C1, C2, C3, C4, C5, C6, TResult> recorder)
-        => query.RecordSlices(span, recorder, CurrentThreadRunner.Instance);
+        => query.RecordSlices(span, recorder, CurrentThreadRunner.Instance, barrier: null);
 
     public unsafe static void RecordSlices<TData, C1, TResult>(
         this IEntityQuery query, Span<TResult> span, in TData userData, DataComponentRecorder<TData, C1, TResult> recorder)
-        => query.RecordSlices(span, userData, recorder, CurrentThreadRunner.Instance);
+        => query.RecordSlices(span, userData, recorder, CurrentThreadRunner.Instance, barrier: null);
 
     public unsafe static void RecordSlices<TData, C1, C2, TResult>(
         this IEntityQuery query, Span<TResult> span, in TData userData, DataComponentRecorder<TData, C1, C2, TResult> recorder)
-        => query.RecordSlices(span, userData, recorder, CurrentThreadRunner.Instance);
+        => query.RecordSlices(span, userData, recorder, CurrentThreadRunner.Instance, barrier: null);
 
     public unsafe static void RecordSlices<TData, C1, C2, C3, TResult>(
         this IEntityQuery query, Span<TResult> span, in TData userData, DataComponentRecorder<TData, C1, C2, C3, TResult> recorder)
-        => query.RecordSlices(span, userData, recorder, CurrentThreadRunner.Instance);
+        => query.RecordSlices(span, userData, recorder, CurrentThreadRunner.Instance, barrier: null);
 
     public unsafe static void RecordSlices<TData, C1, C2, C3, C4, TResult>(
         this IEntityQuery query, Span<TResult> span, in TData userData, DataComponentRecorder<TData, C1, C2, C3, C4, TResult> recorder)
-        => query.RecordSlices(span, userData, recorder, CurrentThreadRunner.Instance);
+        => query.RecordSlices(span, userData, recorder, CurrentThreadRunner.Instance, barrier: null);
 
     public unsafe static void RecordSlices<TData, C1, C2, C3, C4, C5, TResult>(
         this IEntityQuery query, Span<TResult> span, in TData userData, DataComponentRecorder<TData, C1, C2, C3, C4, C5, TResult> recorder)
-        => query.RecordSlices(span, userData, recorder, CurrentThreadRunner.Instance);
+        => query.RecordSlices(span, userData, recorder, CurrentThreadRunner.Instance, barrier: null);
 
     public unsafe static void RecordSlices<TData, C1, C2, C3, C4, C5, C6, TResult>(
         this IEntityQuery query, Span<TResult> span, in TData userData, DataComponentRecorder<TData, C1, C2, C3, C4, C5, C6, TResult> recorder)
-        => query.RecordSlices(span, userData, recorder, CurrentThreadRunner.Instance);
+        => query.RecordSlices(span, userData, recorder, CurrentThreadRunner.Instance, barrier: null);
 
     #endregion // CurrentThreadRunner
 
@@ -429,51 +455,99 @@ public unsafe static void RecordSlices<TData, C1, C2, C3, C4, C5, C6, TResult>(
 
     public unsafe static void RecordSlicesOnParallel<C1, TResult>(
         this IEntityQuery query, Span<TResult> span, ComponentRecorder<C1, TResult> recorder)
-        => query.RecordSlices(span, recorder, ParallelRunner.Default);
+    {
+        var barrier = RunnerBarrier.Get();
+        query.RecordSlices(span, recorder, ParallelRunner.Default, barrier);
+        barrier.WaitAndReturn();
+    }
 
     public unsafe static void RecordSlicesOnParallel<C1, C2, TResult>(
         this IEntityQuery query, Span<TResult> span, ComponentRecorder<C1, C2, TResult> recorder)
-        => query.RecordSlices(span, recorder, ParallelRunner.Default);
+    {
+        var barrier = RunnerBarrier.Get();
+        query.RecordSlices(span, recorder, ParallelRunner.Default, barrier);
+        barrier.WaitAndReturn();
+    }
 
     public unsafe static void RecordSlicesOnParallel<C1, C2, C3, TResult>(
         this IEntityQuery query, Span<TResult> span, ComponentRecorder<C1, C2, C3, TResult> recorder)
-        => query.RecordSlices(span, recorder, ParallelRunner.Default);
+    {
+        var barrier = RunnerBarrier.Get();
+        query.RecordSlices(span, recorder, ParallelRunner.Default, barrier);
+        barrier.WaitAndReturn();
+    }
 
     public unsafe static void RecordSlicesOnParallel<C1, C2, C3, C4, TResult>(
         this IEntityQuery query, Span<TResult> span, ComponentRecorder<C1, C2, C3, C4, TResult> recorder)
-        => query.RecordSlices(span, recorder, ParallelRunner.Default);
+    {
+        var barrier = RunnerBarrier.Get();
+        query.RecordSlices(span, recorder, ParallelRunner.Default, barrier);
+        barrier.WaitAndReturn();
+    }
 
     public unsafe static void RecordSlicesOnParallel<C1, C2, C3, C4, C5, TResult>(
         this IEntityQuery query, Span<TResult> span, ComponentRecorder<C1, C2, C3, C4, C5, TResult> recorder)
-        => query.RecordSlices(span, recorder, ParallelRunner.Default);
+    {
+        var barrier = RunnerBarrier.Get();
+        query.RecordSlices(span, recorder, ParallelRunner.Default, barrier);
+        barrier.WaitAndReturn();
+    }
 
     public unsafe static void RecordSlicesOnParallel<C1, C2, C3, C4, C5, C6, TResult>(
         this IEntityQuery query, Span<TResult> span, ComponentRecorder<C1, C2, C3, C4, C5, C6, TResult> recorder)
-        => query.RecordSlices(span, recorder, ParallelRunner.Default);
+    {
+        var barrier = RunnerBarrier.Get();
+        query.RecordSlices(span, recorder, ParallelRunner.Default, barrier);
+        barrier.WaitAndReturn();
+    }
 
     public unsafe static void RecordSlicesOnParallel<TData, C1, TResult>(
         this IEntityQuery query, Span<TResult> span, in TData userData, DataComponentRecorder<TData, C1, TResult> recorder)
-        => query.RecordSlices(span, userData, recorder, ParallelRunner.Default);
+    {
+        var barrier = RunnerBarrier.Get();
+        query.RecordSlices(span, userData, recorder, ParallelRunner.Default, barrier);
+        barrier.WaitAndReturn();
+    }
 
     public unsafe static void RecordSlicesOnParallel<TData, C1, C2, TResult>(
         this IEntityQuery query, Span<TResult> span, in TData userData, DataComponentRecorder<TData, C1, C2, TResult> recorder)
-        => query.RecordSlices(span, userData, recorder, ParallelRunner.Default);
+    {
+        var barrier = RunnerBarrier.Get();
+        query.RecordSlices(span, userData, recorder, ParallelRunner.Default, barrier);
+        barrier.WaitAndReturn();
+    }
 
     public unsafe static void RecordSlicesOnParallel<TData, C1, C2, C3, TResult>(
         this IEntityQuery query, Span<TResult> span, in TData userData, DataComponentRecorder<TData, C1, C2, C3, TResult> recorder)
-        => query.RecordSlices(span, userData, recorder, ParallelRunner.Default);
+    {
+        var barrier = RunnerBarrier.Get();
+        query.RecordSlices(span, userData, recorder, ParallelRunner.Default, barrier);
+        barrier.WaitAndReturn();
+    }
 
     public unsafe static void RecordSlicesOnParallel<TData, C1, C2, C3, C4, TResult>(
         this IEntityQuery query, Span<TResult> span, in TData userData, DataComponentRecorder<TData, C1, C2, C3, C4, TResult> recorder)
-        => query.RecordSlices(span, userData, recorder, ParallelRunner.Default);
+    {
+        var barrier = RunnerBarrier.Get();
+        query.RecordSlices(span, userData, recorder, ParallelRunner.Default, barrier);
+        barrier.WaitAndReturn();
+    }
 
     public unsafe static void RecordSlicesOnParallel<TData, C1, C2, C3, C4, C5, TResult>(
         this IEntityQuery query, Span<TResult> span, in TData userData, DataComponentRecorder<TData, C1, C2, C3, C4, C5, TResult> recorder)
-        => query.RecordSlices(span, userData, recorder, ParallelRunner.Default);
+    {
+        var barrier = RunnerBarrier.Get();
+        query.RecordSlices(span, userData, recorder, ParallelRunner.Default, barrier);
+        barrier.WaitAndReturn();
+    }
 
     public unsafe static void RecordSlicesOnParallel<TData, C1, C2, C3, C4, C5, C6, TResult>(
         this IEntityQuery query, Span<TResult> span, in TData userData, DataComponentRecorder<TData, C1, C2, C3, C4, C5, C6, TResult> recorder)
-        => query.RecordSlices(span, userData, recorder, ParallelRunner.Default);
+    {
+        var barrier = RunnerBarrier.Get();
+        query.RecordSlices(span, userData, recorder, ParallelRunner.Default, barrier);
+        barrier.WaitAndReturn();
+    }
     #endregion // ParallelRunner
 
     #endregion // ComponentRecorder
diff --git a/Sia/Systems/ParallelSystemBase.cs b/Sia/Systems/ParallelSystemBase.cs
index eb54917..f3de54b 100644
--- a/Sia/Systems/ParallelSystemBase.cs
+++ b/Sia/Systems/ParallelSystemBase.cs
@@ -9,7 +9,11 @@ public abstract class ParallelSystemBase<C1>(
     public IRunner Runner { get; } = runner ?? ParallelRunner.Default;
 
     public override void Execute(World world, Scheduler scheduler, IEntityQuery query)
-        => query.ForSlice<IRunner, C1>(HandleSlice, Runner);
+    {
+        var barrier = RunnerBarrier.Get();
+        query.ForSlice<IRunner, C1>(HandleSlice, Runner, barrier);
+        barrier.WaitAndReturn();
+    }
 
     protected abstract void HandleSlice(ref C1 c1);
 }
@@ -23,7 +27,11 @@ public abstract class ParallelSystemBase<C1, C2>(
     public IRunner Runner { get; } = runner ?? ParallelRunner.Default;
 
     public override void Execute(World world, Scheduler scheduler, IEntityQuery query)
-        => query.ForSlice<IRunner, C1, C2>(OnExecute, Runner);
+    {
+        var barrier = RunnerBarrier.Get();
+        query.ForSlice<IRunner, C1, C2>(OnExecute, Runner, barrier);
+        barrier.WaitAndReturn();
+    }
 
     protected abstract void OnExecute(ref C1 c1, ref C2 c2);
 }
@@ -37,7 +45,11 @@ public abstract class ParallelSystemBase<C1, C2, C3>(
     public IRunner Runner { get; } = runner ?? ParallelRunner.Default;
 
     public override void Execute(World world, Scheduler scheduler, IEntityQuery query)
-        => query.ForSlice<IRunner, C1, C2, C3>(OnExecute, Runner);
+    {
+        var barrier = RunnerBarrier.Get();
+        query.ForSlice<IRunner, C1, C2, C3>(OnExecute, Runner, barrier);
+        barrier.WaitAndReturn();
+    }
 
     protected abstract void OnExecute(ref C1 c1, ref C2 c2, ref C3 c3);
 }
@@ -51,7 +63,11 @@ public abstract class ParallelSystemBase<C1, C2, C3, C4>(
     public IRunner Runner { get; } = runner ?? ParallelRunner.Default;
 
     public override void Execute(World world, Scheduler scheduler, IEntityQuery query)
-        => query.ForSlice<IRunner, C1, C2, C3, C4>(OnExecute, Runner);
+    {
+        var barrier = RunnerBarrier.Get();
+        query.ForSlice<IRunner, C1, C2, C3, C4>(OnExecute, Runner, barrier);
+        barrier.WaitAndReturn();
+    }
 
     protected abstract void OnExecute(ref C1 c1, ref C2 c2, ref C3 c3, ref C4 c4);
 }
@@ -65,7 +81,11 @@ public abstract class ParallelSystemBase<C1, C2, C3, C4, C5>(
     public IRunner Runner { get; } = runner ?? ParallelRunner.Default;
 
     public override void Execute(World world, Scheduler scheduler, IEntityQuery query)
-        => query.ForSlice<IRunner, C1, C2, C3, C4, C5>(OnExecute, Runner);
+    {
+        var barrier = RunnerBarrier.Get();
+        query.ForSlice<IRunner, C1, C2, C3, C4, C5>(OnExecute, Runner, barrier);
+        barrier.WaitAndReturn();
+    }
 
     protected abstract void OnExecute(ref C1 c1, ref C2 c2, ref C3 c3, ref C4 c4, ref C5 c5);
 }
@@ -79,7 +99,11 @@ public abstract class ParallelSystemBase<C1, C2, C3, C4, C5, C6>(
     public IRunner Runner { get; } = runner ?? ParallelRunner.Default;
 
     public override void Execute(World world, Scheduler scheduler, IEntityQuery query)
-        => query.ForSlice<IRunner, C1, C2, C3, C4, C5, C6>(OnExecute, Runner);
+    {
+        var barrier = RunnerBarrier.Get();
+        query.ForSlice<IRunner, C1, C2, C3, C4, C5, C6>(OnExecute, Runner, barrier);
+        barrier.WaitAndReturn();
+    }
 
     protected abstract void OnExecute(ref C1 c1, ref C2 c2, ref C3 c3, ref C4 c4, ref C5 c5, ref C6 c6);
 }
\ No newline at end of file