diff --git a/Src/ILGPU.Algorithms/IL/ILFunctions.cs b/Src/ILGPU.Algorithms/IL/ILFunctions.cs
deleted file mode 100644
index aa19cda85..000000000
--- a/Src/ILGPU.Algorithms/IL/ILFunctions.cs
+++ /dev/null
@@ -1,204 +0,0 @@
-// ---------------------------------------------------------------------------------------
-//                                   ILGPU Algorithms
-//                           Copyright (c) 2021 ILGPU Project
-//                                    www.ilgpu.net
-//
-// File: ILFunctions.cs
-//
-// This file is part of ILGPU and is distributed under the University of Illinois Open
-// Source License. See LICENSE.txt for details.
-// ---------------------------------------------------------------------------------------
-
-using ILGPU.Algorithms.ScanReduceOperations;
-using System;
-using System.Diagnostics;
-using System.Runtime.CompilerServices;
-
-namespace ILGPU.Algorithms.IL
-{
-    /// <summary>
-    /// Custom IL-specific implementations.
-    /// </summary>
-    static class ILFunctions
-    {
-        #region Nested Types
-
-        public interface IILFunctionImplementation
-        {
-            /// <summary>
-            /// The maximum number of supported thread per context on the CPU accelerator
-            /// for the implementation of specific algorithms.
-            /// </summary>
-            int MaxNumThreads { get; }
-
-            /// <summary>
-            /// Returns true if the current thread is the first thread.
-            /// </summary>
-            bool IsFirstThread { get; }
-
-            /// <summary>
-            /// Returns the current linear thread index.
-            /// </summary>
-            int ThreadIndex { get; }
-
-            /// <summary>
-            /// Returns the linear thread dimension.
-            /// </summary>
-            int ThreadDimension { get; }
-
-            /// <summary>
-            /// The number of segments for reduce operations.
-            /// </summary>
-            int ReduceSegments { get; }
-
-            /// <summary>
-            /// The reduction segment index to write to and read from.
-            /// </summary>
-            int ReduceSegmentIndex { get; }
-
-            /// <summary>
-            /// Executes a barrier in the current context.
-            /// </summary>
-            void Barrier();
-        }
-
-        #endregion
-
-        #region Reduce
-
-        /// <summary cref="GroupExtensions.Reduce{T, TReduction}(T)"/>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static T Reduce<T, TReduction, TImpl>(T value)
-            where T : unmanaged
-            where TReduction : IScanReduceOperation<T>
-            where TImpl : struct, IILFunctionImplementation =>
-            AllReduce<T, TReduction, TImpl>(value);
-
-        /// <summary cref="GroupExtensions.AllReduce{T, TReduction}(T)"/>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static T AllReduce<T, TReduction, TImpl>(T value)
-            where T : unmanaged
-            where TReduction : IScanReduceOperation<T>
-            where TImpl : struct, IILFunctionImplementation
-        {
-            TImpl impl = default;
-            var sharedMemory = SharedMemory.Allocate<T>(impl.ReduceSegments);
-
-            TReduction reduction = default;
-            if (impl.IsFirstThread)
-                sharedMemory[impl.ReduceSegmentIndex] = reduction.Identity;
-            impl.Barrier();
-
-            reduction.AtomicApply(ref sharedMemory[impl.ReduceSegmentIndex], value);
-
-            impl.Barrier();
-            return sharedMemory[impl.ReduceSegmentIndex];
-        }
-
-        #endregion
-
-        #region Scan
-
-        /// <summary cref="GroupExtensions.ExclusiveScan{T, TScanOperation}(T)"/>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static T ExclusiveScan<T, TScanOperation, TImpl>(T value)
-            where T : unmanaged
-            where TScanOperation : struct, IScanReduceOperation<T>
-            where TImpl : struct, IILFunctionImplementation =>
-            ExclusiveScanWithBoundaries<T, TScanOperation, TImpl>(value, out var _);
-
-        /// <summary cref="GroupExtensions.InclusiveScan{T, TScanOperation}(T)"/>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static T InclusiveScan<T, TScanOperation, TImpl>(T value)
-            where T : unmanaged
-            where TScanOperation : struct, IScanReduceOperation<T>
-            where TImpl : struct, IILFunctionImplementation =>
-            InclusiveScanWithBoundaries<T, TScanOperation, TImpl>(value, out var _);
-
-        /// <summary cref="GroupExtensions.ExclusiveScanWithBoundaries{T, TScanOperation}(
-        /// T, out ScanBoundaries{T})"/>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static T ExclusiveScanWithBoundaries<T, TScanOperation, TImpl>(
-            T value,
-            out ScanBoundaries<T> boundaries)
-            where T : unmanaged
-            where TScanOperation : struct, IScanReduceOperation<T>
-            where TImpl : struct, IILFunctionImplementation
-        {
-            TImpl impl = default;
-            var sharedMemory = InclusiveScanImplementation<T, TScanOperation, TImpl>(
-                value);
-            boundaries = new ScanBoundaries<T>(
-                sharedMemory[0],
-                sharedMemory[Math.Max(0, impl.ThreadDimension - 2)]);
-            return impl.IsFirstThread
-                ? default(TScanOperation).Identity
-                : sharedMemory[impl.ThreadIndex - 1];
-        }
-
-        /// <summary cref="GroupExtensions.InclusiveScanWithBoundaries{T, TScanOperation}(
-        /// T, out ScanBoundaries{T})"/>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static T InclusiveScanWithBoundaries<T, TScanOperation, TImpl>(
-            T value,
-            out ScanBoundaries<T> boundaries)
-            where T : unmanaged
-            where TScanOperation : struct, IScanReduceOperation<T>
-            where TImpl : struct, IILFunctionImplementation
-        {
-            TImpl impl = default;
-            var sharedMemory = InclusiveScanImplementation<T, TScanOperation, TImpl>(
-                value);
-            boundaries = new ScanBoundaries<T>(
-                sharedMemory[0],
-                sharedMemory[impl.ThreadDimension - 1]);
-            return sharedMemory[impl.ThreadIndex];
-        }
-
-        /// <summary>
-        /// Performs a group-wide inclusive scan.
-        /// </summary>
-        /// <typeparam name="T">The element type.</typeparam>
-        /// <typeparam name="TScanOperation">The type of the warp scan logic.</typeparam>
-        /// <typeparam name="TImpl">The internal implementation type.</typeparam>
-        /// <param name="value">The value to scan.</param>
-        /// <returns>The resulting value for the current lane.</returns>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        private static ArrayView<T> InclusiveScanImplementation<
-            T,
-            TScanOperation,
-            TImpl>(
-            T value)
-            where T : unmanaged
-            where TScanOperation : struct, IScanReduceOperation<T>
-            where TImpl : struct, IILFunctionImplementation
-        {
-            TImpl impl = default;
-
-            // Load values into shared memory
-            var sharedMemory = SharedMemory.Allocate<T>(impl.MaxNumThreads);
-            Debug.Assert(
-                impl.ThreadDimension <= impl.MaxNumThreads,
-                "Invalid group/warp size");
-            sharedMemory[impl.ThreadIndex] = value;
-            impl.Barrier();
-
-            // First thread performs all operations
-            if (impl.IsFirstThread)
-            {
-                TScanOperation scanOperation = default;
-                for (int i = 1; i < impl.ThreadDimension; ++i)
-                {
-                    sharedMemory[i] = scanOperation.Apply(
-                        sharedMemory[i - 1],
-                        sharedMemory[i]);
-                }
-            }
-            impl.Barrier();
-
-            return sharedMemory;
-        }
-
-        #endregion
-    }
-}
diff --git a/Src/ILGPU.Algorithms/IL/ILGroupExtensions.cs b/Src/ILGPU.Algorithms/IL/ILGroupExtensions.cs
index af0d43fad..f4f1db1db 100644
--- a/Src/ILGPU.Algorithms/IL/ILGroupExtensions.cs
+++ b/Src/ILGPU.Algorithms/IL/ILGroupExtensions.cs
@@ -1,6 +1,6 @@
 // ---------------------------------------------------------------------------------------
 //                                   ILGPU Algorithms
-//                        Copyright (c) 2019-2021 ILGPU Project
+//                        Copyright (c) 2019-2022 ILGPU Project
 //                                    www.ilgpu.net
 //
 // File: ILGroupExtensions.cs
@@ -10,8 +10,9 @@
 // ---------------------------------------------------------------------------------------
 
 using ILGPU.Algorithms.ScanReduceOperations;
+using System;
+using System.Diagnostics;
 using System.Runtime.CompilerServices;
-using static ILGPU.Algorithms.IL.ILFunctions;
 
 namespace ILGPU.Algorithms.IL
 {
@@ -20,54 +21,6 @@ namespace ILGPU.Algorithms.IL
     /// </summary>
     static class ILGroupExtensions
     {
-        #region Nested Types
-
-        /// <summary>
-        /// Implements ILFunctions for groups.
-        /// </summary>
-        private readonly struct GroupImplementation : IILFunctionImplementation
-        {
-            /// <summary>
-            /// Returns 1024.
-            /// </summary>
-            /// <remarks>
-            /// TODO: refine the implementation to avoid a hard-coded constant.
-            /// </remarks>
-            public readonly int MaxNumThreads => 1024;
-
-            /// <summary>
-            /// Returns true if this is the first group thread.
-            /// </summary>
-            public readonly bool IsFirstThread => Group.IsFirstThread;
-
-            /// <summary>
-            /// Returns current linear group index.
-            /// </summary>
-            public readonly int ThreadIndex => Group.LinearIndex;
-
-            /// <summary>
-            /// Returns the linear group dimension.
-            /// </summary>
-            public readonly int ThreadDimension => Group.Dimension.Size;
-
-            /// <summary>
-            /// Returns 1.
-            /// </summary>
-            public readonly int ReduceSegments => 1;
-
-            /// <summary>
-            /// Returns 0.
-            /// </summary>
-            public readonly int ReduceSegmentIndex => 0;
-
-            /// <summary>
-            /// Performs a group-wide barrier.
-            /// </summary>
-            public readonly void Barrier() => Group.Barrier();
-        }
-
-        #endregion
-
         #region Reduce
 
         /// <summary cref="GroupExtensions.Reduce{T, TReduction}(T)"/>
@@ -81,8 +34,23 @@ public static T Reduce<T, TReduction>(T value)
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static T AllReduce<T, TReduction>(T value)
             where T : unmanaged
-            where TReduction : IScanReduceOperation<T> =>
-            AllReduce<T, TReduction, GroupImplementation>(value);
+            where TReduction : IScanReduceOperation<T>
+        {
+            TReduction reduction = default;
+
+            ref var sharedMemory = ref SharedMemory.Allocate<T>();
+            if (Group.IsFirstThread)
+                sharedMemory = reduction.Identity;
+            Group.Barrier();
+
+            // Reduce inside all warps first
+            var firstLaneReduced = ILWarpExtensions.Reduce<T, TReduction>(value);
+            if (Warp.IsFirstLane)
+                reduction.AtomicApply(ref sharedMemory, firstLaneReduced);
+
+            Group.Barrier();
+            return sharedMemory;
+        }
 
         #endregion
 
@@ -93,14 +61,14 @@ public static T AllReduce<T, TReduction>(T value)
         public static T ExclusiveScan<T, TScanOperation>(T value)
             where T : unmanaged
             where TScanOperation : struct, IScanReduceOperation<T> =>
-            ExclusiveScan<T, TScanOperation, GroupImplementation>(value);
+            ExclusiveScanWithBoundaries<T, TScanOperation>(value, out var _);
 
         /// <summary cref="GroupExtensions.InclusiveScan{T, TScanOperation}(T)"/>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static T InclusiveScan<T, TScanOperation>(T value)
             where T : unmanaged
             where TScanOperation : struct, IScanReduceOperation<T> =>
-            InclusiveScan<T, TScanOperation, GroupImplementation>(value);
+            InclusiveScanWithBoundaries<T, TScanOperation>(value, out var _);
 
         /// <summary cref="GroupExtensions.ExclusiveScanWithBoundaries{T, TScanOperation}(
         /// T, out ScanBoundaries{T})"/>
@@ -109,10 +77,16 @@ public static T ExclusiveScanWithBoundaries<T, TScanOperation>(
             T value,
             out ScanBoundaries<T> boundaries)
             where T : unmanaged
-            where TScanOperation : struct, IScanReduceOperation<T> =>
-            ExclusiveScanWithBoundaries<T, TScanOperation, GroupImplementation>(
-                value,
-                out boundaries);
+            where TScanOperation : struct, IScanReduceOperation<T>
+        {
+            var sharedMemory = InclusiveScanImplementation<T, TScanOperation>(value);
+            boundaries = new ScanBoundaries<T>(
+                sharedMemory[0],
+                sharedMemory[Math.Max(0, Group.Dimension.Size - 2)]);
+            return Group.IsFirstThread
+                ? default(TScanOperation).Identity
+                : sharedMemory[Group.LinearIndex - 1];
+        }
 
         /// <summary cref="GroupExtensions.InclusiveScanWithBoundaries{T, TScanOperation}(
         /// T, out ScanBoundaries{T})"/>
@@ -121,10 +95,54 @@ public static T InclusiveScanWithBoundaries<T, TScanOperation>(
             T value,
             out ScanBoundaries<T> boundaries)
             where T : unmanaged
-            where TScanOperation : struct, IScanReduceOperation<T> =>
-            InclusiveScanWithBoundaries<T, TScanOperation, GroupImplementation>(
-                value,
-                out boundaries);
+            where TScanOperation : struct, IScanReduceOperation<T>
+        {
+            var sharedMemory = InclusiveScanImplementation<T, TScanOperation>(
+                value);
+            boundaries = new ScanBoundaries<T>(
+                sharedMemory[0],
+                sharedMemory[Group.Dimension.Size - 1]);
+            return sharedMemory[Group.LinearIndex];
+        }
+
+        /// <summary>
+        /// Performs a group-wide inclusive scan.
+        /// </summary>
+        /// <typeparam name="T">The element type.</typeparam>
+        /// <typeparam name="TScanOperation">The type of the warp scan logic.</typeparam>
+        /// <param name="value">The value to scan.</param>
+        /// <returns>The resulting value for the current lane.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private static ArrayView<T> InclusiveScanImplementation<T, TScanOperation>(
+            T value)
+            where T : unmanaged
+            where TScanOperation : struct, IScanReduceOperation<T>
+        {
+            const int MaxNumThreads = 2048;
+
+            // Load values into shared memory
+            var sharedMemory = SharedMemory.Allocate<T>(MaxNumThreads);
+            Debug.Assert(
+                Group.Dimension.Size <= MaxNumThreads,
+                "Invalid group/warp size");
+            sharedMemory[Group.LinearIndex] = value;
+            Group.Barrier();
+
+            // First thread performs all operations
+            if (Group.IsFirstThread)
+            {
+                TScanOperation scanOperation = default;
+                for (int i = 1; i < Group.Dimension.Size; ++i)
+                {
+                    sharedMemory[i] = scanOperation.Apply(
+                        sharedMemory[i - 1],
+                        sharedMemory[i]);
+                }
+            }
+            Group.Barrier();
+
+            return sharedMemory;
+        }
 
         /// <summary>
         /// Prepares for the next iteration of a group-wide exclusive scan within the
diff --git a/Src/ILGPU.Algorithms/IL/ILWarpExtensions.cs b/Src/ILGPU.Algorithms/IL/ILWarpExtensions.cs
index 7b1b56069..f4f987400 100644
--- a/Src/ILGPU.Algorithms/IL/ILWarpExtensions.cs
+++ b/Src/ILGPU.Algorithms/IL/ILWarpExtensions.cs
@@ -1,6 +1,6 @@
 // ---------------------------------------------------------------------------------------
 //                                   ILGPU Algorithms
-//                        Copyright (c) 2019-2021 ILGPU Project
+//                        Copyright (c) 2019-2022 ILGPU Project
 //                                    www.ilgpu.net
 //
 // File: ILWarpExtensions.cs
@@ -9,65 +9,18 @@
 // Source License. See LICENSE.txt for details.
 // ---------------------------------------------------------------------------------------
 
+using ILGPU.Algorithms.PTX;
 using ILGPU.Algorithms.ScanReduceOperations;
 using System.Runtime.CompilerServices;
-using static ILGPU.Algorithms.IL.ILFunctions;
 
 namespace ILGPU.Algorithms.IL
 {
     /// <summary>
-    /// Custom IL-specific implementations.
+    /// Custom IL-specific implementations that fall back to PTX-specific implementations
+    /// as the CPU runtime is fully compatible with the PTX runtime.
     /// </summary>
     static class ILWarpExtensions
     {
-        #region Nested Types
-
-        /// <summary>
-        /// Implements ILFunctions for warps.
-        /// </summary>
-        private readonly struct WarpImplementation : IILFunctionImplementation
-        {
-            /// <summary>
-            /// Returns 256.
-            /// </summary>
-            /// <remarks>
-            /// TODO: refine the implementation to avoid a hard-coded constant.
-            /// </remarks>
-            public readonly int MaxNumThreads => 256;
-
-            /// <summary>
-            /// Returns true if this is the first warp thread.
-            /// </summary>
-            public readonly bool IsFirstThread => Warp.IsFirstLane;
-
-            /// <summary>
-            /// Returns current lane index.
-            /// </summary>
-            public readonly int ThreadIndex => Warp.LaneIdx;
-
-            /// <summary>
-            /// Returns the warp size.
-            /// </summary>
-            public readonly int ThreadDimension => Warp.WarpSize;
-
-            /// <summary>
-            /// Returns the number of warps per group.
-            /// </summary>
-            public readonly int ReduceSegments => MaxNumThreads / Warp.WarpSize;
-
-            /// <summary>
-            /// Returns the current warp index.
-            /// </summary>
-            public readonly int ReduceSegmentIndex => Warp.WarpIdx;
-
-            /// <summary>
-            /// Performs a warp-wide barrier.
-            /// </summary>
-            public readonly void Barrier() => Warp.Barrier();
-        }
-
-        #endregion
-
         #region Reduce
 
         /// <summary cref="WarpExtensions.Reduce{T, TReduction}(T)"/>
@@ -75,14 +28,14 @@ static class ILWarpExtensions
         public static T Reduce<T, TReduction>(T value)
             where T : unmanaged
             where TReduction : IScanReduceOperation<T> =>
-            AllReduce<T, TReduction>(value);
+            PTXWarpExtensions.Reduce<T, TReduction>(value);
 
         /// <summary cref="WarpExtensions.AllReduce{T, TReduction}(T)"/>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static T AllReduce<T, TReduction>(T value)
             where T : unmanaged
             where TReduction : IScanReduceOperation<T> =>
-            AllReduce<T, TReduction, WarpImplementation>(value);
+            PTXWarpExtensions.AllReduce<T, TReduction>(value);
 
         #endregion
 
@@ -93,14 +46,14 @@ public static T AllReduce<T, TReduction>(T value)
         public static T ExclusiveScan<T, TScanOperation>(T value)
             where T : unmanaged
             where TScanOperation : struct, IScanReduceOperation<T> =>
-            ExclusiveScan<T, TScanOperation, WarpImplementation>(value);
+            PTXWarpExtensions.ExclusiveScan<T, TScanOperation>(value);
 
         /// <summary cref="WarpExtensions.InclusiveScan{T, TScanOperation}(T)"/>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static T InclusiveScan<T, TScanOperation>(T value)
             where T : unmanaged
             where TScanOperation : struct, IScanReduceOperation<T> =>
-            InclusiveScan<T, TScanOperation, WarpImplementation>(value);
+            PTXWarpExtensions.InclusiveScan<T, TScanOperation>(value);
 
         #endregion
     }