diff --git a/OnnxStack.StableDiffusion/Helpers/TensorHelper.cs b/OnnxStack.StableDiffusion/Helpers/TensorHelper.cs
index c7a368a8..60fbda3c 100644
--- a/OnnxStack.StableDiffusion/Helpers/TensorHelper.cs
+++ b/OnnxStack.StableDiffusion/Helpers/TensorHelper.cs
@@ -3,7 +3,7 @@
 using System.Collections.Generic;
 using System.Linq;
 using System.Numerics;
-
+using System.Numerics.Tensors;
 namespace OnnxStack.StableDiffusion.Helpers
 {
 
@@ -14,6 +14,7 @@ namespace OnnxStack.StableDiffusion.Helpers
     public static class TensorHelper
     {
         private static readonly int vectorSize = Vector<float>.Count;
+
         /// <summary>
         /// Creates a new tensor.
         /// </summary>
@@ -44,17 +45,9 @@ public static DenseTensor<T> CreateTensor<T>(T[] data, ReadOnlySpan<int> dimensi
         /// <returns></returns>
         public static DenseTensor<float> MultiplyTensorByFloat(this DenseTensor<float> tensor, float value)
         {
-            var mullTensor = new DenseTensor<float>(tensor.Dimensions);
-            for (int i = 0; i < tensor.Length / vectorSize; i++)
-            {
-                (new Vector<float>(tensor.Buffer.Span.Slice(i * vectorSize, vectorSize)) * value)
-                    .CopyTo(mullTensor.Buffer.Span.Slice(i * vectorSize, vectorSize));
-            }
-            for (int i = (int)(tensor.Length - tensor.Length % vectorSize); i < tensor.Length; i++)
-            {
-                mullTensor.Buffer.Span[i] = tensor.Buffer.Span[i] * value;
-            }
-            return mullTensor;
+            var result = new DenseTensor<float>(tensor.Dimensions);
+            TensorPrimitives.Multiply(tensor.Buffer.Span, value, result.Buffer.Span);
+            return result;
         }
 
 
@@ -66,20 +59,12 @@ public static DenseTensor<float> MultiplyTensorByFloat(this DenseTensor<float> t
         /// <returns></returns>
         public static DenseTensor<float> SubtractFloat(this DenseTensor<float> tensor, float value)
         {
-            var subTensor = new DenseTensor<float>(tensor.Dimensions);
-            Vector<float> vectorValue = new Vector<float>(value);
-            for (int i = 0; i < tensor.Length / vectorSize; i++)
-            {
-                Vector.Subtract(new Vector<float>(tensor.Buffer.Span.Slice(i * vectorSize, vectorSize)), vectorValue)
-                    .CopyTo(subTensor.Buffer.Span.Slice(i * vectorSize, vectorSize));
-            }
-            for (int i = (int)(tensor.Length - tensor.Length % vectorSize); i < tensor.Length; i++)
-            {
-                subTensor.Buffer.Span[i] = tensor.Buffer.Span[i] - value;
-            }
-            return subTensor;
+            var result = new DenseTensor<float>(tensor.Dimensions);
+            TensorPrimitives.Subtract(tensor.Buffer.Span, value, result.Buffer.Span);
+            return result;
         }
 
+
         /// <summary>
         /// Adds the tensors.
         /// </summary>
@@ -88,18 +73,9 @@ public static DenseTensor<float> SubtractFloat(this DenseTensor<float> tensor, f
         /// <returns></returns>
         public static DenseTensor<float> AddTensors(this DenseTensor<float> tensor, DenseTensor<float> sumTensor)
         {
-            var addTensor = new DenseTensor<float>(tensor.Dimensions);
-            for (int i = 0; i < tensor.Length / vectorSize; i++)
-            {
-                (new Vector<float>(tensor.Buffer.Span.Slice(i * vectorSize, vectorSize))
-                    + new Vector<float>(sumTensor.Buffer.Span.Slice(i * vectorSize, vectorSize)))
-                    .CopyTo(addTensor.Buffer.Span.Slice(i * vectorSize, vectorSize));
-            }
-            for (int i = (int)(tensor.Length - tensor.Length % vectorSize); i < tensor.Length; i++)
-            {
-                addTensor.Buffer.Span[i] = tensor.Buffer.Span[i] + sumTensor.Buffer.Span[i];
-            }
-            return addTensor;
+            var result = new DenseTensor<float>(tensor.Dimensions);
+            TensorPrimitives.Add(tensor.Buffer.Span, sumTensor.Buffer.Span, result.Buffer.Span);
+            return result;
         }
 
 
@@ -111,12 +87,12 @@ public static DenseTensor<float> AddTensors(this DenseTensor<float> tensor, Dens
         /// <returns></returns>
         public static DenseTensor<float> SumTensors(this DenseTensor<float>[] tensors, ReadOnlySpan<int> dimensions)
         {
-            var sumTensor = new DenseTensor<float>(dimensions);
+            var result = new DenseTensor<float>(dimensions);
             for (int m = 0; m < tensors.Length; m++)
             {
-                sumTensor.Add(tensors[m]);
+                TensorPrimitives.Add(result.Buffer.Span, tensors[m].Buffer.Span, result.Buffer.Span);
             }
-            return sumTensor;
+            return result;
         }
 
 
@@ -129,68 +105,31 @@ public static DenseTensor<float> SumTensors(this DenseTensor<float>[] tensors, R
         public static DenseTensor<float> SubtractTensors(this DenseTensor<float> tensor, DenseTensor<float> subTensor)
         {
             var result = new DenseTensor<float>(tensor.Dimensions);
-            for (int i = 0; i < tensor.Length / vectorSize; i++)
-            {
-                (new Vector<float>(tensor.Buffer.Span.Slice(i * vectorSize, vectorSize))
-                    - new Vector<float>(subTensor.Buffer.Span.Slice(i * vectorSize, vectorSize)))
-                    .CopyTo(result.Buffer.Span.Slice(i * vectorSize, vectorSize));
-            }
-            for (int i = (int)(tensor.Length - tensor.Length % vectorSize); i < tensor.Length; i++)
-            {
-                result.Buffer.Span[i] = tensor.Buffer.Span[i] - subTensor.Buffer.Span[i];
-            }
+            TensorPrimitives.Subtract(tensor.Buffer.Span, subTensor.Buffer.Span, result.Buffer.Span);
             return result;
         }
 
-
         /// <summary>
-        /// Reorders the tensor.
+        /// Divides the tensor by float, mutates the original
         /// </summary>
-        /// <param name="tensor">The input tensor.</param>
+        /// <param name="tensor">The tensor to mutate.</param>
+        /// <param name="value">The value to divide by.</param>
         /// <returns></returns>
-        public static DenseTensor<float> ReorderTensor(this DenseTensor<float> tensor, ReadOnlySpan<int> dimensions)
+        public static DenseTensor<float> DivideBy(this DenseTensor<float> tensor, float value)
         {
-            //reorder from batch channel height width to batch height width channel
-            var inputImagesTensor = new DenseTensor<float>(dimensions);
-            for (int y = 0; y < tensor.Dimensions[2]; y++)
-            {
-                for (int x = 0; x < tensor.Dimensions[3]; x++)
-                {
-                    inputImagesTensor[0, y, x, 0] = tensor[0, 0, y, x];
-                    inputImagesTensor[0, y, x, 1] = tensor[0, 1, y, x];
-                    inputImagesTensor[0, y, x, 2] = tensor[0, 2, y, x];
-                }
-            }
-            return inputImagesTensor;
+            value = 1 / value;
+            TensorPrimitives.Multiply(tensor.Buffer.Span, value, tensor.Buffer.Span);
+            return tensor;
         }
 
 
         /// <summary>
-        /// Clips the specified Tensor valuse to the specified minimum/maximum.
+        /// Multiples the tensor by float, mutates the original
         /// </summary>
-        /// <param name="tensor">The tensor.</param>
-        /// <param name="minValue">The minimum value.</param>
-        /// <param name="maxValue">The maximum value.</param>
+        /// <param name="tensor">The tensor to mutate.</param>
+        /// <param name="value">The value to multiply by.</param>
         /// <returns></returns>
-        public static DenseTensor<float> Clip(this DenseTensor<float> tensor, float minValue, float maxValue)
-        {
-            Vector<float> min = new Vector<float>(minValue);
-            Vector<float> max = new Vector<float>(maxValue);
-            var clipTensor = new DenseTensor<float>(tensor.Dimensions);
-            for (int i = 0; i < tensor.Length / vectorSize; i++)
-            {
-                Vector.Min(min,
-                    Vector.Max(max,
-                    new Vector<float>(tensor.Buffer.Span.Slice(i * vectorSize, vectorSize))))
-                    .CopyTo(clipTensor.Buffer.Span.Slice(i * vectorSize, vectorSize));
-            }
-            for (int i = (int)(tensor.Length - tensor.Length % vectorSize); i < tensor.Length; i++)
-            {
-                clipTensor.Buffer.Span[i] = Math.Clamp(tensor.Buffer.Span[i], minValue, maxValue);
-            }
-            return clipTensor;
-            
-        }
+        public static DenseTensor<float> MultiplyBy(this DenseTensor<float> tensor, float value) => DivideBy(tensor, 1 / value);
 
 
         /// <summary>
@@ -200,16 +139,7 @@ public static DenseTensor<float> Clip(this DenseTensor<float> tensor, float minV
         /// <returns></returns>
         public static DenseTensor<float> Abs(this DenseTensor<float> tensor)
         {
-            for (int i = 0; i < tensor.Length / vectorSize; i++)
-            {
-                Span<float> buffer = tensor.Buffer.Span.Slice(i * vectorSize, vectorSize);
-                Vector.Abs(new Vector<float>(buffer))
-                    .CopyTo(buffer);
-            }
-            for (int i = (int)(tensor.Length - tensor.Length % vectorSize); i < tensor.Length; i++)
-            {
-                tensor.Buffer.Span[i] = Math.Abs(tensor.Buffer.Span[i]);
-            }
+            TensorPrimitives.Abs(tensor.Buffer.Span, tensor.Buffer.Span);
             return tensor;
         }
 
@@ -222,16 +152,7 @@ public static DenseTensor<float> Abs(this DenseTensor<float> tensor)
         /// <returns></returns>
         public static DenseTensor<float> Multiply(this DenseTensor<float> tensor, DenseTensor<float> mulTensor)
         {
-            for (int i = 0; i < tensor.Length / vectorSize; i++)
-            {
-                (new Vector<float>(tensor.Buffer.Span.Slice(i * vectorSize, vectorSize))
-                    * new Vector<float>(mulTensor.Buffer.Span.Slice(i * vectorSize, vectorSize)))
-                    .CopyTo(tensor.Buffer.Span.Slice(i * vectorSize, vectorSize));
-            }
-            for (int i = (int)(tensor.Length - tensor.Length % vectorSize); i < tensor.Length; i++)
-            {
-                tensor.Buffer.Span[i] = tensor.Buffer.Span[i] * mulTensor.Buffer.Span[i];
-            }
+            TensorPrimitives.Multiply(tensor.Buffer.Span, mulTensor.Buffer.Span, tensor.Buffer.Span);
             return tensor;
         }
 
@@ -244,17 +165,85 @@ public static DenseTensor<float> Multiply(this DenseTensor<float> tensor, DenseT
         /// <returns></returns>
         public static DenseTensor<float> Divide(this DenseTensor<float> tensor, DenseTensor<float> divTensor)
         {
+            TensorPrimitives.Divide(tensor.Buffer.Span, divTensor.Buffer.Span, tensor.Buffer.Span);
+            return tensor;
+        }
+
+
+        /// <summary>
+        /// Adds the tensors, mutates the original
+        /// </summary>
+        /// <param name="tensor">The tensor to mutate.</param>
+        /// <param name="addTensor">The tensor values to add to tensor.</param>
+        /// <returns></returns>
+        public static DenseTensor<float> Add(this DenseTensor<float> tensor, DenseTensor<float> addTensor)
+        {
+            TensorPrimitives.Add(tensor.Buffer.Span, addTensor.Buffer.Span, tensor.Buffer.Span);
+            return tensor;
+        }
+
+
+        /// <summary>
+        /// Subtracts the tensors, mutates the original
+        /// </summary>
+        /// <param name="tensor">The tensor to mutate.</param>
+        /// <param name="subTensor">The tensor to subtract from tensor.</param>
+        /// <param name="dimensions">The dimensions.</param>
+        /// <returns></returns>
+        public static DenseTensor<float> Subtract(this DenseTensor<float> tensor, DenseTensor<float> subTensor)
+        {
+            TensorPrimitives.Subtract(tensor.Buffer.Span, subTensor.Buffer.Span, tensor.Buffer.Span);
+            return tensor;
+        }
+
+
+        /// <summary>
+        /// Reorders the tensor.
+        /// </summary>
+        /// <param name="tensor">The input tensor.</param>
+        /// <returns></returns>
+        public static DenseTensor<float> ReorderTensor(this DenseTensor<float> tensor, ReadOnlySpan<int> dimensions)
+        {
+            //reorder from batch channel height width to batch height width channel
+            var inputImagesTensor = new DenseTensor<float>(dimensions);
+            for (int y = 0; y < tensor.Dimensions[2]; y++)
+            {
+                for (int x = 0; x < tensor.Dimensions[3]; x++)
+                {
+                    inputImagesTensor[0, y, x, 0] = tensor[0, 0, y, x];
+                    inputImagesTensor[0, y, x, 1] = tensor[0, 1, y, x];
+                    inputImagesTensor[0, y, x, 2] = tensor[0, 2, y, x];
+                }
+            }
+            return inputImagesTensor;
+        }
+
+
+        /// <summary>
+        /// Clips the specified Tensor valuse to the specified minimum/maximum.
+        /// </summary>
+        /// <param name="tensor">The tensor.</param>
+        /// <param name="minValue">The minimum value.</param>
+        /// <param name="maxValue">The maximum value.</param>
+        /// <returns></returns>
+        public static DenseTensor<float> Clip(this DenseTensor<float> tensor, float minValue, float maxValue)
+        {
+            Vector<float> min = new Vector<float>(minValue);
+            Vector<float> max = new Vector<float>(maxValue);
+            var clipTensor = new DenseTensor<float>(tensor.Dimensions);
             for (int i = 0; i < tensor.Length / vectorSize; i++)
             {
-                (new Vector<float>(tensor.Buffer.Span.Slice(i * vectorSize, vectorSize))
-                    / new Vector<float>(divTensor.Buffer.Span.Slice(i * vectorSize, vectorSize)))
-                    .CopyTo(tensor.Buffer.Span.Slice(i * vectorSize, vectorSize));
+                Vector.Min(min,
+                    Vector.Max(max,
+                    new Vector<float>(tensor.Buffer.Span.Slice(i * vectorSize, vectorSize))))
+                    .CopyTo(clipTensor.Buffer.Span.Slice(i * vectorSize, vectorSize));
             }
             for (int i = (int)(tensor.Length - tensor.Length % vectorSize); i < tensor.Length; i++)
             {
-                tensor.Buffer.Span[i] = tensor.Buffer.Span[i] / divTensor.Buffer.Span[i];
+                clipTensor.Buffer.Span[i] = Math.Clamp(tensor.Buffer.Span[i], minValue, maxValue);
             }
-            return tensor;
+            return clipTensor;
+
         }
 
 
@@ -283,6 +272,7 @@ public static DenseTensor<float> Concatenate(this DenseTensor<float> tensor1, De
             return new DenseTensor<float>(buffer, dimensions);
         }
 
+
         private static DenseTensor<float> Concatenate(DenseTensor<float> tensor1, DenseTensor<float> tensor2)
         {
             var dimensions = new int[] { tensor1.Dimensions[0], tensor1.Dimensions[1], tensor1.Dimensions[2] + tensor2.Dimensions[2] };
@@ -304,7 +294,6 @@ private static DenseTensor<float> Concatenate(DenseTensor<float> tensor1, DenseT
         }
 
 
-
         /// <summary>
         /// Repeats the specified Tensor along the 0 axis.
         /// </summary>
@@ -408,82 +397,5 @@ public static DenseTensor<float> Join(this IList<DenseTensor<float>> tensors, in
             }
             return new DenseTensor<float>(buffer, dimensions);
         }
-
-
-        /// <summary>
-        /// Adds the tensors, mutates the original
-        /// </summary>
-        /// <param name="tensor">The tensor to mutate.</param>
-        /// <param name="addTensor">The tensor values to add to tensor.</param>
-        /// <returns></returns>
-        public static DenseTensor<float> Add(this DenseTensor<float> tensor, DenseTensor<float> addTensor)
-        {
-            for (int i = 0; i < tensor.Length / vectorSize; i++)
-            {
-                (new Vector<float>(tensor.Buffer.Span.Slice(i * vectorSize, vectorSize))
-                    + new Vector<float>(addTensor.Buffer.Span.Slice(i * vectorSize, vectorSize)))
-                    .CopyTo(tensor.Buffer.Span.Slice(i * vectorSize, vectorSize));
-            }
-            for (int i = (int)(tensor.Length - tensor.Length % vectorSize); i < tensor.Length; i++)
-            {
-                tensor.Buffer.Span[i] = tensor.Buffer.Span[i] + addTensor.Buffer.Span[i];
-            }
-            return tensor;
-        }
-
-
-        /// <summary>
-        /// Subtracts the tensors, mutates the original
-        /// </summary>
-        /// <param name="tensor">The tensor to mutate.</param>
-        /// <param name="subTensor">The tensor to subtract from tensor.</param>
-        /// <param name="dimensions">The dimensions.</param>
-        /// <returns></returns>
-        public static DenseTensor<float> Subtract(this DenseTensor<float> tensor, DenseTensor<float> subTensor)
-        {
-            for (int i = 0; i < tensor.Length / vectorSize; i++)
-            {
-                (new Vector<float>(tensor.Buffer.Span.Slice(i * vectorSize, vectorSize))
-                    - new Vector<float>(subTensor.Buffer.Span.Slice(i * vectorSize, vectorSize)))
-                    .CopyTo(tensor.Buffer.Span.Slice(i * vectorSize, vectorSize));
-            }
-            for (int i = (int)(tensor.Length - tensor.Length % vectorSize); i < tensor.Length; i++)
-            {
-                tensor.Buffer.Span[i] = tensor.Buffer.Span[i] - subTensor.Buffer.Span[i];
-            }
-            return tensor;
-        }
-
-
-        /// <summary>
-        /// Divides the tensor by float, mutates the original
-        /// </summary>
-        /// <param name="tensor">The tensor to mutate.</param>
-        /// <param name="value">The value to divide by.</param>
-        /// <returns></returns>
-        public static DenseTensor<float> DivideBy(this DenseTensor<float> tensor, float value)
-        {
-            value = 1 / value;
-            var mullTensor = new DenseTensor<float>(tensor.Dimensions);
-            for (int i = 0; i < tensor.Length / vectorSize; i++)
-            {
-                (new Vector<float>(tensor.Buffer.Span.Slice(i * vectorSize, vectorSize)) * value)
-                    .CopyTo(mullTensor.Buffer.Span.Slice(i * vectorSize, vectorSize));
-            }
-            for (int i = (int)(tensor.Length - tensor.Length % vectorSize); i < tensor.Length; i++)
-            {
-                mullTensor.Buffer.Span[i] = tensor.Buffer.Span[i] * value;
-            }
-            return mullTensor;
-        }
-
-
-        /// <summary>
-        /// Multiples the tensor by float, mutates the original
-        /// </summary>
-        /// <param name="tensor">The tensor to mutate.</param>
-        /// <param name="value">The value to multiply by.</param>
-        /// <returns></returns>
-        public static DenseTensor<float> MultiplyBy(this DenseTensor<float> tensor, float value) => DivideBy(tensor, 1 / value);
     }
 }