From 41cfa9b1fb9fa9e3c80a67433263124a2470389f Mon Sep 17 00:00:00 2001
From: James Jackson-South <james_south@hotmail.com>
Date: Sun, 19 Feb 2023 15:59:10 +1000
Subject: [PATCH] Port DefaultPixelBlenders

---
 .../DefaultPixelBlenders.Generated.cs         | 7470 ++++++++++++++++-
 .../DefaultPixelBlenders.Generated.tt         |   73 +-
 2 files changed, 7100 insertions(+), 443 deletions(-)

diff --git a/src/ImageSharp/PixelFormats/PixelBlenders/DefaultPixelBlenders.Generated.cs b/src/ImageSharp/PixelFormats/PixelBlenders/DefaultPixelBlenders.Generated.cs
index cf1910121..c2d97efa0 100644
--- a/src/ImageSharp/PixelFormats/PixelBlenders/DefaultPixelBlenders.Generated.cs
+++ b/src/ImageSharp/PixelFormats/PixelBlenders/DefaultPixelBlenders.Generated.cs
@@ -3,6 +3,10 @@
 
 // <auto-generated />
 using System.Numerics;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using System.Runtime.Intrinsics;
+using System.Runtime.Intrinsics.X86;
 
 namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders;
 
@@ -43,18 +47,79 @@ internal static class DefaultPixelBlenders<TPixel>
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
         {
             amount = Numerics.Clamp(amount, 0, 1);
-            for (int i = 0; i < destination.Length; i++)
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.NormalSrc(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.NormalSrc(background[i], source[i], amount);
+                }
+            }
+            else
             {
-                destination[i] = PorterDuffFunctions.NormalSrc(background[i], source[i], amount);
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.NormalSrc(background[i], source[i], amount);
+                }
             }
         }
 
         /// <inheritdoc />
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
         {
-            for (int i = 0; i < destination.Length; i++)
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // TODO: It would be better if we can clamp this outside of the loop using our SIMD methods.
+                    Vector256<float> opacity = Vector256.Create(Numerics.Clamp(amountBase, 0, 1F));
+
+                    destinationBase = PorterDuffFunctions.NormalSrc(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.NormalSrc(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
             {
-                destination[i] = PorterDuffFunctions.NormalSrc(background[i], source[i], Numerics.Clamp(amount[i], 0, 1));
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.NormalSrc(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
             }
         }
     }
@@ -81,18 +146,79 @@ internal static class DefaultPixelBlenders<TPixel>
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
         {
             amount = Numerics.Clamp(amount, 0, 1);
-            for (int i = 0; i < destination.Length; i++)
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.MultiplySrc(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.MultiplySrc(background[i], source[i], amount);
+                }
+            }
+            else
             {
-                destination[i] = PorterDuffFunctions.MultiplySrc(background[i], source[i], amount);
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.MultiplySrc(background[i], source[i], amount);
+                }
             }
         }
 
         /// <inheritdoc />
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
         {
-            for (int i = 0; i < destination.Length; i++)
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // TODO: It would be better if we can clamp this outside of the loop using our SIMD methods.
+                    Vector256<float> opacity = Vector256.Create(Numerics.Clamp(amountBase, 0, 1F));
+
+                    destinationBase = PorterDuffFunctions.MultiplySrc(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.MultiplySrc(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
             {
-                destination[i] = PorterDuffFunctions.MultiplySrc(background[i], source[i], Numerics.Clamp(amount[i], 0, 1));
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.MultiplySrc(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
             }
         }
     }
@@ -119,18 +245,79 @@ internal static class DefaultPixelBlenders<TPixel>
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
         {
             amount = Numerics.Clamp(amount, 0, 1);
-            for (int i = 0; i < destination.Length; i++)
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.AddSrc(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.AddSrc(background[i], source[i], amount);
+                }
+            }
+            else
             {
-                destination[i] = PorterDuffFunctions.AddSrc(background[i], source[i], amount);
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.AddSrc(background[i], source[i], amount);
+                }
             }
         }
 
         /// <inheritdoc />
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
         {
-            for (int i = 0; i < destination.Length; i++)
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // TODO: It would be better if we can clamp this outside of the loop using our SIMD methods.
+                    Vector256<float> opacity = Vector256.Create(Numerics.Clamp(amountBase, 0, 1F));
+
+                    destinationBase = PorterDuffFunctions.AddSrc(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.AddSrc(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
             {
-                destination[i] = PorterDuffFunctions.AddSrc(background[i], source[i], Numerics.Clamp(amount[i], 0, 1));
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.AddSrc(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
             }
         }
     }
@@ -157,18 +344,79 @@ internal static class DefaultPixelBlenders<TPixel>
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
         {
             amount = Numerics.Clamp(amount, 0, 1);
-            for (int i = 0; i < destination.Length; i++)
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.SubtractSrc(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.SubtractSrc(background[i], source[i], amount);
+                }
+            }
+            else
             {
-                destination[i] = PorterDuffFunctions.SubtractSrc(background[i], source[i], amount);
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.SubtractSrc(background[i], source[i], amount);
+                }
             }
         }
 
         /// <inheritdoc />
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
         {
-            for (int i = 0; i < destination.Length; i++)
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // TODO: It would be better if we can clamp this outside of the loop using our SIMD methods.
+                    Vector256<float> opacity = Vector256.Create(Numerics.Clamp(amountBase, 0, 1F));
+
+                    destinationBase = PorterDuffFunctions.SubtractSrc(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.SubtractSrc(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
             {
-                destination[i] = PorterDuffFunctions.SubtractSrc(background[i], source[i], Numerics.Clamp(amount[i], 0, 1));
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.SubtractSrc(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
             }
         }
     }
@@ -195,18 +443,79 @@ internal static class DefaultPixelBlenders<TPixel>
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
         {
             amount = Numerics.Clamp(amount, 0, 1);
-            for (int i = 0; i < destination.Length; i++)
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.ScreenSrc(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.ScreenSrc(background[i], source[i], amount);
+                }
+            }
+            else
             {
-                destination[i] = PorterDuffFunctions.ScreenSrc(background[i], source[i], amount);
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.ScreenSrc(background[i], source[i], amount);
+                }
             }
         }
 
         /// <inheritdoc />
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
         {
-            for (int i = 0; i < destination.Length; i++)
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // TODO: It would be better if we can clamp this outside of the loop using our SIMD methods.
+                    Vector256<float> opacity = Vector256.Create(Numerics.Clamp(amountBase, 0, 1F));
+
+                    destinationBase = PorterDuffFunctions.ScreenSrc(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.ScreenSrc(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
             {
-                destination[i] = PorterDuffFunctions.ScreenSrc(background[i], source[i], Numerics.Clamp(amount[i], 0, 1));
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.ScreenSrc(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
             }
         }
     }
@@ -233,18 +542,79 @@ internal static class DefaultPixelBlenders<TPixel>
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
         {
             amount = Numerics.Clamp(amount, 0, 1);
-            for (int i = 0; i < destination.Length; i++)
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.DarkenSrc(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.DarkenSrc(background[i], source[i], amount);
+                }
+            }
+            else
             {
-                destination[i] = PorterDuffFunctions.DarkenSrc(background[i], source[i], amount);
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.DarkenSrc(background[i], source[i], amount);
+                }
             }
         }
 
         /// <inheritdoc />
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
         {
-            for (int i = 0; i < destination.Length; i++)
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // TODO: It would be better if we can clamp this outside of the loop using our SIMD methods.
+                    Vector256<float> opacity = Vector256.Create(Numerics.Clamp(amountBase, 0, 1F));
+
+                    destinationBase = PorterDuffFunctions.DarkenSrc(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.DarkenSrc(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
             {
-                destination[i] = PorterDuffFunctions.DarkenSrc(background[i], source[i], Numerics.Clamp(amount[i], 0, 1));
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.DarkenSrc(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
             }
         }
     }
@@ -271,18 +641,79 @@ internal static class DefaultPixelBlenders<TPixel>
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
         {
             amount = Numerics.Clamp(amount, 0, 1);
-            for (int i = 0; i < destination.Length; i++)
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.LightenSrc(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.LightenSrc(background[i], source[i], amount);
+                }
+            }
+            else
             {
-                destination[i] = PorterDuffFunctions.LightenSrc(background[i], source[i], amount);
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.LightenSrc(background[i], source[i], amount);
+                }
             }
         }
 
         /// <inheritdoc />
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
         {
-            for (int i = 0; i < destination.Length; i++)
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // TODO: It would be better if we can clamp this outside of the loop using our SIMD methods.
+                    Vector256<float> opacity = Vector256.Create(Numerics.Clamp(amountBase, 0, 1F));
+
+                    destinationBase = PorterDuffFunctions.LightenSrc(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.LightenSrc(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
             {
-                destination[i] = PorterDuffFunctions.LightenSrc(background[i], source[i], Numerics.Clamp(amount[i], 0, 1));
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.LightenSrc(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
             }
         }
     }
@@ -309,18 +740,79 @@ internal static class DefaultPixelBlenders<TPixel>
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
         {
             amount = Numerics.Clamp(amount, 0, 1);
-            for (int i = 0; i < destination.Length; i++)
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.OverlaySrc(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.OverlaySrc(background[i], source[i], amount);
+                }
+            }
+            else
             {
-                destination[i] = PorterDuffFunctions.OverlaySrc(background[i], source[i], amount);
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.OverlaySrc(background[i], source[i], amount);
+                }
             }
         }
 
         /// <inheritdoc />
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
         {
-            for (int i = 0; i < destination.Length; i++)
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // TODO: It would be better if we can clamp this outside of the loop using our SIMD methods.
+                    Vector256<float> opacity = Vector256.Create(Numerics.Clamp(amountBase, 0, 1F));
+
+                    destinationBase = PorterDuffFunctions.OverlaySrc(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.OverlaySrc(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
             {
-                destination[i] = PorterDuffFunctions.OverlaySrc(background[i], source[i], Numerics.Clamp(amount[i], 0, 1));
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.OverlaySrc(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
             }
         }
     }
@@ -347,18 +839,79 @@ internal static class DefaultPixelBlenders<TPixel>
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
         {
             amount = Numerics.Clamp(amount, 0, 1);
-            for (int i = 0; i < destination.Length; i++)
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.HardLightSrc(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.HardLightSrc(background[i], source[i], amount);
+                }
+            }
+            else
             {
-                destination[i] = PorterDuffFunctions.HardLightSrc(background[i], source[i], amount);
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.HardLightSrc(background[i], source[i], amount);
+                }
             }
         }
 
         /// <inheritdoc />
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
         {
-            for (int i = 0; i < destination.Length; i++)
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // TODO: It would be better if we can clamp this outside of the loop using our SIMD methods.
+                    Vector256<float> opacity = Vector256.Create(Numerics.Clamp(amountBase, 0, 1F));
+
+                    destinationBase = PorterDuffFunctions.HardLightSrc(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.HardLightSrc(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
             {
-                destination[i] = PorterDuffFunctions.HardLightSrc(background[i], source[i], Numerics.Clamp(amount[i], 0, 1));
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.HardLightSrc(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
             }
         }
     }
@@ -385,18 +938,79 @@ internal static class DefaultPixelBlenders<TPixel>
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
         {
             amount = Numerics.Clamp(amount, 0, 1);
-            for (int i = 0; i < destination.Length; i++)
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.NormalSrcAtop(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.NormalSrcAtop(background[i], source[i], amount);
+                }
+            }
+            else
             {
-                destination[i] = PorterDuffFunctions.NormalSrcAtop(background[i], source[i], amount);
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.NormalSrcAtop(background[i], source[i], amount);
+                }
             }
         }
 
         /// <inheritdoc />
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
         {
-            for (int i = 0; i < destination.Length; i++)
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // TODO: It would be better if we can clamp this outside of the loop using our SIMD methods.
+                    Vector256<float> opacity = Vector256.Create(Numerics.Clamp(amountBase, 0, 1F));
+
+                    destinationBase = PorterDuffFunctions.NormalSrcAtop(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.NormalSrcAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
             {
-                destination[i] = PorterDuffFunctions.NormalSrcAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1));
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.NormalSrcAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
             }
         }
     }
@@ -423,18 +1037,79 @@ internal static class DefaultPixelBlenders<TPixel>
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
         {
             amount = Numerics.Clamp(amount, 0, 1);
-            for (int i = 0; i < destination.Length; i++)
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.MultiplySrcAtop(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.MultiplySrcAtop(background[i], source[i], amount);
+                }
+            }
+            else
             {
-                destination[i] = PorterDuffFunctions.MultiplySrcAtop(background[i], source[i], amount);
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.MultiplySrcAtop(background[i], source[i], amount);
+                }
             }
         }
 
         /// <inheritdoc />
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
         {
-            for (int i = 0; i < destination.Length; i++)
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // TODO: It would be better if we can clamp this outside of the loop using our SIMD methods.
+                    Vector256<float> opacity = Vector256.Create(Numerics.Clamp(amountBase, 0, 1F));
+
+                    destinationBase = PorterDuffFunctions.MultiplySrcAtop(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.MultiplySrcAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
             {
-                destination[i] = PorterDuffFunctions.MultiplySrcAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1));
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.MultiplySrcAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
             }
         }
     }
@@ -461,18 +1136,79 @@ internal static class DefaultPixelBlenders<TPixel>
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
         {
             amount = Numerics.Clamp(amount, 0, 1);
-            for (int i = 0; i < destination.Length; i++)
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.AddSrcAtop(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.AddSrcAtop(background[i], source[i], amount);
+                }
+            }
+            else
             {
-                destination[i] = PorterDuffFunctions.AddSrcAtop(background[i], source[i], amount);
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.AddSrcAtop(background[i], source[i], amount);
+                }
             }
         }
 
         /// <inheritdoc />
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
         {
-            for (int i = 0; i < destination.Length; i++)
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // TODO: It would be better if we can clamp this outside of the loop using our SIMD methods.
+                    Vector256<float> opacity = Vector256.Create(Numerics.Clamp(amountBase, 0, 1F));
+
+                    destinationBase = PorterDuffFunctions.AddSrcAtop(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.AddSrcAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
             {
-                destination[i] = PorterDuffFunctions.AddSrcAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1));
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.AddSrcAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
             }
         }
     }
@@ -499,18 +1235,79 @@ internal static class DefaultPixelBlenders<TPixel>
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
         {
             amount = Numerics.Clamp(amount, 0, 1);
-            for (int i = 0; i < destination.Length; i++)
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.SubtractSrcAtop(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.SubtractSrcAtop(background[i], source[i], amount);
+                }
+            }
+            else
             {
-                destination[i] = PorterDuffFunctions.SubtractSrcAtop(background[i], source[i], amount);
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.SubtractSrcAtop(background[i], source[i], amount);
+                }
             }
         }
 
         /// <inheritdoc />
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
         {
-            for (int i = 0; i < destination.Length; i++)
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // TODO: It would be better if we can clamp this outside of the loop using our SIMD methods.
+                    Vector256<float> opacity = Vector256.Create(Numerics.Clamp(amountBase, 0, 1F));
+
+                    destinationBase = PorterDuffFunctions.SubtractSrcAtop(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.SubtractSrcAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
             {
-                destination[i] = PorterDuffFunctions.SubtractSrcAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1));
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.SubtractSrcAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
             }
         }
     }
@@ -537,18 +1334,79 @@ internal static class DefaultPixelBlenders<TPixel>
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
         {
             amount = Numerics.Clamp(amount, 0, 1);
-            for (int i = 0; i < destination.Length; i++)
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.ScreenSrcAtop(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.ScreenSrcAtop(background[i], source[i], amount);
+                }
+            }
+            else
             {
-                destination[i] = PorterDuffFunctions.ScreenSrcAtop(background[i], source[i], amount);
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.ScreenSrcAtop(background[i], source[i], amount);
+                }
             }
         }
 
         /// <inheritdoc />
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
         {
-            for (int i = 0; i < destination.Length; i++)
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // TODO: It would be better if we can clamp this outside of the loop using our SIMD methods.
+                    Vector256<float> opacity = Vector256.Create(Numerics.Clamp(amountBase, 0, 1F));
+
+                    destinationBase = PorterDuffFunctions.ScreenSrcAtop(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.ScreenSrcAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
             {
-                destination[i] = PorterDuffFunctions.ScreenSrcAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1));
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.ScreenSrcAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
             }
         }
     }
@@ -575,18 +1433,79 @@ internal static class DefaultPixelBlenders<TPixel>
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
         {
             amount = Numerics.Clamp(amount, 0, 1);
-            for (int i = 0; i < destination.Length; i++)
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.DarkenSrcAtop(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.DarkenSrcAtop(background[i], source[i], amount);
+                }
+            }
+            else
             {
-                destination[i] = PorterDuffFunctions.DarkenSrcAtop(background[i], source[i], amount);
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.DarkenSrcAtop(background[i], source[i], amount);
+                }
             }
         }
 
         /// <inheritdoc />
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
         {
-            for (int i = 0; i < destination.Length; i++)
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // TODO: It would be better if we can clamp this outside of the loop using our SIMD methods.
+                    Vector256<float> opacity = Vector256.Create(Numerics.Clamp(amountBase, 0, 1F));
+
+                    destinationBase = PorterDuffFunctions.DarkenSrcAtop(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.DarkenSrcAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
             {
-                destination[i] = PorterDuffFunctions.DarkenSrcAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1));
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.DarkenSrcAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
             }
         }
     }
@@ -613,18 +1532,79 @@ internal static class DefaultPixelBlenders<TPixel>
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
         {
             amount = Numerics.Clamp(amount, 0, 1);
-            for (int i = 0; i < destination.Length; i++)
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.LightenSrcAtop(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.LightenSrcAtop(background[i], source[i], amount);
+                }
+            }
+            else
             {
-                destination[i] = PorterDuffFunctions.LightenSrcAtop(background[i], source[i], amount);
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.LightenSrcAtop(background[i], source[i], amount);
+                }
             }
         }
 
         /// <inheritdoc />
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
         {
-            for (int i = 0; i < destination.Length; i++)
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // TODO: It would be better if we can clamp this outside of the loop using our SIMD methods.
+                    Vector256<float> opacity = Vector256.Create(Numerics.Clamp(amountBase, 0, 1F));
+
+                    destinationBase = PorterDuffFunctions.LightenSrcAtop(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.LightenSrcAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
             {
-                destination[i] = PorterDuffFunctions.LightenSrcAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1));
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.LightenSrcAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
             }
         }
     }
@@ -651,18 +1631,79 @@ internal static class DefaultPixelBlenders<TPixel>
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
         {
             amount = Numerics.Clamp(amount, 0, 1);
-            for (int i = 0; i < destination.Length; i++)
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.OverlaySrcAtop(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.OverlaySrcAtop(background[i], source[i], amount);
+                }
+            }
+            else
             {
-                destination[i] = PorterDuffFunctions.OverlaySrcAtop(background[i], source[i], amount);
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.OverlaySrcAtop(background[i], source[i], amount);
+                }
             }
         }
 
         /// <inheritdoc />
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
         {
-            for (int i = 0; i < destination.Length; i++)
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // TODO: It would be better if we can clamp this outside of the loop using our SIMD methods.
+                    Vector256<float> opacity = Vector256.Create(Numerics.Clamp(amountBase, 0, 1F));
+
+                    destinationBase = PorterDuffFunctions.OverlaySrcAtop(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.OverlaySrcAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
             {
-                destination[i] = PorterDuffFunctions.OverlaySrcAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1));
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.OverlaySrcAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
             }
         }
     }
@@ -689,18 +1730,79 @@ internal static class DefaultPixelBlenders<TPixel>
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
         {
             amount = Numerics.Clamp(amount, 0, 1);
-            for (int i = 0; i < destination.Length; i++)
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.HardLightSrcAtop(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.HardLightSrcAtop(background[i], source[i], amount);
+                }
+            }
+            else
             {
-                destination[i] = PorterDuffFunctions.HardLightSrcAtop(background[i], source[i], amount);
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.HardLightSrcAtop(background[i], source[i], amount);
+                }
             }
         }
 
         /// <inheritdoc />
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
         {
-            for (int i = 0; i < destination.Length; i++)
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // TODO: It would be better if we can clamp this outside of the loop using our SIMD methods.
+                    Vector256<float> opacity = Vector256.Create(Numerics.Clamp(amountBase, 0, 1F));
+
+                    destinationBase = PorterDuffFunctions.HardLightSrcAtop(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.HardLightSrcAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
             {
-                destination[i] = PorterDuffFunctions.HardLightSrcAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1));
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.HardLightSrcAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
             }
         }
     }
@@ -727,18 +1829,79 @@ internal static class DefaultPixelBlenders<TPixel>
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
         {
             amount = Numerics.Clamp(amount, 0, 1);
-            for (int i = 0; i < destination.Length; i++)
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.NormalSrcOver(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.NormalSrcOver(background[i], source[i], amount);
+                }
+            }
+            else
             {
-                destination[i] = PorterDuffFunctions.NormalSrcOver(background[i], source[i], amount);
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.NormalSrcOver(background[i], source[i], amount);
+                }
             }
         }
 
         /// <inheritdoc />
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
         {
-            for (int i = 0; i < destination.Length; i++)
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // TODO: It would be better if we can clamp this outside of the loop using our SIMD methods.
+                    Vector256<float> opacity = Vector256.Create(Numerics.Clamp(amountBase, 0, 1F));
+
+                    destinationBase = PorterDuffFunctions.NormalSrcOver(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.NormalSrcOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
             {
-                destination[i] = PorterDuffFunctions.NormalSrcOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1));
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.NormalSrcOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
             }
         }
     }
@@ -765,18 +1928,79 @@ internal static class DefaultPixelBlenders<TPixel>
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
         {
             amount = Numerics.Clamp(amount, 0, 1);
-            for (int i = 0; i < destination.Length; i++)
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.MultiplySrcOver(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.MultiplySrcOver(background[i], source[i], amount);
+                }
+            }
+            else
             {
-                destination[i] = PorterDuffFunctions.MultiplySrcOver(background[i], source[i], amount);
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.MultiplySrcOver(background[i], source[i], amount);
+                }
             }
         }
 
         /// <inheritdoc />
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
         {
-            for (int i = 0; i < destination.Length; i++)
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // TODO: It would be better if we can clamp this outside of the loop using our SIMD methods.
+                    Vector256<float> opacity = Vector256.Create(Numerics.Clamp(amountBase, 0, 1F));
+
+                    destinationBase = PorterDuffFunctions.MultiplySrcOver(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.MultiplySrcOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
             {
-                destination[i] = PorterDuffFunctions.MultiplySrcOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1));
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.MultiplySrcOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
             }
         }
     }
@@ -803,18 +2027,79 @@ internal static class DefaultPixelBlenders<TPixel>
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
         {
             amount = Numerics.Clamp(amount, 0, 1);
-            for (int i = 0; i < destination.Length; i++)
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.AddSrcOver(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.AddSrcOver(background[i], source[i], amount);
+                }
+            }
+            else
             {
-                destination[i] = PorterDuffFunctions.AddSrcOver(background[i], source[i], amount);
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.AddSrcOver(background[i], source[i], amount);
+                }
             }
         }
 
         /// <inheritdoc />
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
         {
-            for (int i = 0; i < destination.Length; i++)
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // TODO: It would be better if we can clamp this outside of the loop using our SIMD methods.
+                    Vector256<float> opacity = Vector256.Create(Numerics.Clamp(amountBase, 0, 1F));
+
+                    destinationBase = PorterDuffFunctions.AddSrcOver(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.AddSrcOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
             {
-                destination[i] = PorterDuffFunctions.AddSrcOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1));
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.AddSrcOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
             }
         }
     }
@@ -841,18 +2126,79 @@ internal static class DefaultPixelBlenders<TPixel>
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
         {
             amount = Numerics.Clamp(amount, 0, 1);
-            for (int i = 0; i < destination.Length; i++)
+
+            if (Avx2.IsSupported && destination.Length >= 2)
             {
-                destination[i] = PorterDuffFunctions.SubtractSrcOver(background[i], source[i], amount);
-            }
-        }
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
 
-        /// <inheritdoc />
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.SubtractSrcOver(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.SubtractSrcOver(background[i], source[i], amount);
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.SubtractSrcOver(background[i], source[i], amount);
+                }
+            }
+        }
+
+        /// <inheritdoc />
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
         {
-            for (int i = 0; i < destination.Length; i++)
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // TODO: It would be better if we can clamp this outside of the loop using our SIMD methods.
+                    Vector256<float> opacity = Vector256.Create(Numerics.Clamp(amountBase, 0, 1F));
+
+                    destinationBase = PorterDuffFunctions.SubtractSrcOver(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.SubtractSrcOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
             {
-                destination[i] = PorterDuffFunctions.SubtractSrcOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1));
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.SubtractSrcOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
             }
         }
     }
@@ -879,18 +2225,79 @@ internal static class DefaultPixelBlenders<TPixel>
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
         {
             amount = Numerics.Clamp(amount, 0, 1);
-            for (int i = 0; i < destination.Length; i++)
+
+            if (Avx2.IsSupported && destination.Length >= 2)
             {
-                destination[i] = PorterDuffFunctions.ScreenSrcOver(background[i], source[i], amount);
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.ScreenSrcOver(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.ScreenSrcOver(background[i], source[i], amount);
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.ScreenSrcOver(background[i], source[i], amount);
+                }
             }
         }
 
         /// <inheritdoc />
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
         {
-            for (int i = 0; i < destination.Length; i++)
+            if (Avx2.IsSupported && destination.Length >= 2)
             {
-                destination[i] = PorterDuffFunctions.ScreenSrcOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1));
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // TODO: It would be better if we can clamp this outside of the loop using our SIMD methods.
+                    Vector256<float> opacity = Vector256.Create(Numerics.Clamp(amountBase, 0, 1F));
+
+                    destinationBase = PorterDuffFunctions.ScreenSrcOver(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.ScreenSrcOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.ScreenSrcOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
             }
         }
     }
@@ -917,18 +2324,79 @@ internal static class DefaultPixelBlenders<TPixel>
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
         {
             amount = Numerics.Clamp(amount, 0, 1);
-            for (int i = 0; i < destination.Length; i++)
+
+            if (Avx2.IsSupported && destination.Length >= 2)
             {
-                destination[i] = PorterDuffFunctions.DarkenSrcOver(background[i], source[i], amount);
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.DarkenSrcOver(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.DarkenSrcOver(background[i], source[i], amount);
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.DarkenSrcOver(background[i], source[i], amount);
+                }
             }
         }
 
         /// <inheritdoc />
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
         {
-            for (int i = 0; i < destination.Length; i++)
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // TODO: It would be better if we can clamp this outside of the loop using our SIMD methods.
+                    Vector256<float> opacity = Vector256.Create(Numerics.Clamp(amountBase, 0, 1F));
+
+                    destinationBase = PorterDuffFunctions.DarkenSrcOver(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.DarkenSrcOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
             {
-                destination[i] = PorterDuffFunctions.DarkenSrcOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1));
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.DarkenSrcOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
             }
         }
     }
@@ -955,18 +2423,79 @@ internal static class DefaultPixelBlenders<TPixel>
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
         {
             amount = Numerics.Clamp(amount, 0, 1);
-            for (int i = 0; i < destination.Length; i++)
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.LightenSrcOver(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.LightenSrcOver(background[i], source[i], amount);
+                }
+            }
+            else
             {
-                destination[i] = PorterDuffFunctions.LightenSrcOver(background[i], source[i], amount);
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.LightenSrcOver(background[i], source[i], amount);
+                }
             }
         }
 
         /// <inheritdoc />
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
         {
-            for (int i = 0; i < destination.Length; i++)
+            if (Avx2.IsSupported && destination.Length >= 2)
             {
-                destination[i] = PorterDuffFunctions.LightenSrcOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1));
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // TODO: It would be better if we can clamp this outside of the loop using our SIMD methods.
+                    Vector256<float> opacity = Vector256.Create(Numerics.Clamp(amountBase, 0, 1F));
+
+                    destinationBase = PorterDuffFunctions.LightenSrcOver(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.LightenSrcOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.LightenSrcOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
             }
         }
     }
@@ -993,18 +2522,79 @@ internal static class DefaultPixelBlenders<TPixel>
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
         {
             amount = Numerics.Clamp(amount, 0, 1);
-            for (int i = 0; i < destination.Length; i++)
+
+            if (Avx2.IsSupported && destination.Length >= 2)
             {
-                destination[i] = PorterDuffFunctions.OverlaySrcOver(background[i], source[i], amount);
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.OverlaySrcOver(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.OverlaySrcOver(background[i], source[i], amount);
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.OverlaySrcOver(background[i], source[i], amount);
+                }
             }
         }
 
         /// <inheritdoc />
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
         {
-            for (int i = 0; i < destination.Length; i++)
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // TODO: It would be better if we can clamp this outside of the loop using our SIMD methods.
+                    Vector256<float> opacity = Vector256.Create(Numerics.Clamp(amountBase, 0, 1F));
+
+                    destinationBase = PorterDuffFunctions.OverlaySrcOver(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.OverlaySrcOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
             {
-                destination[i] = PorterDuffFunctions.OverlaySrcOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1));
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.OverlaySrcOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
             }
         }
     }
@@ -1031,18 +2621,79 @@ internal static class DefaultPixelBlenders<TPixel>
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
         {
             amount = Numerics.Clamp(amount, 0, 1);
-            for (int i = 0; i < destination.Length; i++)
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.HardLightSrcOver(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.HardLightSrcOver(background[i], source[i], amount);
+                }
+            }
+            else
             {
-                destination[i] = PorterDuffFunctions.HardLightSrcOver(background[i], source[i], amount);
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.HardLightSrcOver(background[i], source[i], amount);
+                }
             }
         }
 
         /// <inheritdoc />
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
         {
-            for (int i = 0; i < destination.Length; i++)
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // TODO: It would be better if we can clamp this outside of the loop using our SIMD methods.
+                    Vector256<float> opacity = Vector256.Create(Numerics.Clamp(amountBase, 0, 1F));
+
+                    destinationBase = PorterDuffFunctions.HardLightSrcOver(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.HardLightSrcOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
             {
-                destination[i] = PorterDuffFunctions.HardLightSrcOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1));
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.HardLightSrcOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
             }
         }
     }
@@ -1069,18 +2720,79 @@ internal static class DefaultPixelBlenders<TPixel>
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
         {
             amount = Numerics.Clamp(amount, 0, 1);
-            for (int i = 0; i < destination.Length; i++)
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.NormalSrcIn(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.NormalSrcIn(background[i], source[i], amount);
+                }
+            }
+            else
             {
-                destination[i] = PorterDuffFunctions.NormalSrcIn(background[i], source[i], amount);
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.NormalSrcIn(background[i], source[i], amount);
+                }
             }
         }
 
         /// <inheritdoc />
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
         {
-            for (int i = 0; i < destination.Length; i++)
+            if (Avx2.IsSupported && destination.Length >= 2)
             {
-                destination[i] = PorterDuffFunctions.NormalSrcIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1));
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // TODO: It would be better if we can clamp this outside of the loop using our SIMD methods.
+                    Vector256<float> opacity = Vector256.Create(Numerics.Clamp(amountBase, 0, 1F));
+
+                    destinationBase = PorterDuffFunctions.NormalSrcIn(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.NormalSrcIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.NormalSrcIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
             }
         }
     }
@@ -1107,18 +2819,79 @@ internal static class DefaultPixelBlenders<TPixel>
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
         {
             amount = Numerics.Clamp(amount, 0, 1);
-            for (int i = 0; i < destination.Length; i++)
+
+            if (Avx2.IsSupported && destination.Length >= 2)
             {
-                destination[i] = PorterDuffFunctions.MultiplySrcIn(background[i], source[i], amount);
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.MultiplySrcIn(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.MultiplySrcIn(background[i], source[i], amount);
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.MultiplySrcIn(background[i], source[i], amount);
+                }
             }
         }
 
         /// <inheritdoc />
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
         {
-            for (int i = 0; i < destination.Length; i++)
+            if (Avx2.IsSupported && destination.Length >= 2)
             {
-                destination[i] = PorterDuffFunctions.MultiplySrcIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1));
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // TODO: It would be better if we can clamp this outside of the loop using our SIMD methods.
+                    Vector256<float> opacity = Vector256.Create(Numerics.Clamp(amountBase, 0, 1F));
+
+                    destinationBase = PorterDuffFunctions.MultiplySrcIn(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.MultiplySrcIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.MultiplySrcIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
             }
         }
     }
@@ -1145,18 +2918,79 @@ internal static class DefaultPixelBlenders<TPixel>
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
         {
             amount = Numerics.Clamp(amount, 0, 1);
-            for (int i = 0; i < destination.Length; i++)
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.AddSrcIn(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.AddSrcIn(background[i], source[i], amount);
+                }
+            }
+            else
             {
-                destination[i] = PorterDuffFunctions.AddSrcIn(background[i], source[i], amount);
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.AddSrcIn(background[i], source[i], amount);
+                }
             }
         }
 
         /// <inheritdoc />
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
         {
-            for (int i = 0; i < destination.Length; i++)
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // TODO: It would be better if we can clamp this outside of the loop using our SIMD methods.
+                    Vector256<float> opacity = Vector256.Create(Numerics.Clamp(amountBase, 0, 1F));
+
+                    destinationBase = PorterDuffFunctions.AddSrcIn(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.AddSrcIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
             {
-                destination[i] = PorterDuffFunctions.AddSrcIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1));
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.AddSrcIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
             }
         }
     }
@@ -1183,18 +3017,79 @@ internal static class DefaultPixelBlenders<TPixel>
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
         {
             amount = Numerics.Clamp(amount, 0, 1);
-            for (int i = 0; i < destination.Length; i++)
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.SubtractSrcIn(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.SubtractSrcIn(background[i], source[i], amount);
+                }
+            }
+            else
             {
-                destination[i] = PorterDuffFunctions.SubtractSrcIn(background[i], source[i], amount);
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.SubtractSrcIn(background[i], source[i], amount);
+                }
             }
         }
 
         /// <inheritdoc />
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
         {
-            for (int i = 0; i < destination.Length; i++)
+            if (Avx2.IsSupported && destination.Length >= 2)
             {
-                destination[i] = PorterDuffFunctions.SubtractSrcIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1));
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // TODO: It would be better if we can clamp this outside of the loop using our SIMD methods.
+                    Vector256<float> opacity = Vector256.Create(Numerics.Clamp(amountBase, 0, 1F));
+
+                    destinationBase = PorterDuffFunctions.SubtractSrcIn(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.SubtractSrcIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.SubtractSrcIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
             }
         }
     }
@@ -1221,18 +3116,79 @@ internal static class DefaultPixelBlenders<TPixel>
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
         {
             amount = Numerics.Clamp(amount, 0, 1);
-            for (int i = 0; i < destination.Length; i++)
+
+            if (Avx2.IsSupported && destination.Length >= 2)
             {
-                destination[i] = PorterDuffFunctions.ScreenSrcIn(background[i], source[i], amount);
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.ScreenSrcIn(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.ScreenSrcIn(background[i], source[i], amount);
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.ScreenSrcIn(background[i], source[i], amount);
+                }
             }
         }
 
         /// <inheritdoc />
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
         {
-            for (int i = 0; i < destination.Length; i++)
+            if (Avx2.IsSupported && destination.Length >= 2)
             {
-                destination[i] = PorterDuffFunctions.ScreenSrcIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1));
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // TODO: It would be better if we can clamp this outside of the loop using our SIMD methods.
+                    Vector256<float> opacity = Vector256.Create(Numerics.Clamp(amountBase, 0, 1F));
+
+                    destinationBase = PorterDuffFunctions.ScreenSrcIn(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.ScreenSrcIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.ScreenSrcIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
             }
         }
     }
@@ -1259,18 +3215,79 @@ internal static class DefaultPixelBlenders<TPixel>
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
         {
             amount = Numerics.Clamp(amount, 0, 1);
-            for (int i = 0; i < destination.Length; i++)
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.DarkenSrcIn(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.DarkenSrcIn(background[i], source[i], amount);
+                }
+            }
+            else
             {
-                destination[i] = PorterDuffFunctions.DarkenSrcIn(background[i], source[i], amount);
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.DarkenSrcIn(background[i], source[i], amount);
+                }
             }
         }
 
         /// <inheritdoc />
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
         {
-            for (int i = 0; i < destination.Length; i++)
+            if (Avx2.IsSupported && destination.Length >= 2)
             {
-                destination[i] = PorterDuffFunctions.DarkenSrcIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1));
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // TODO: It would be better if we can clamp this outside of the loop using our SIMD methods.
+                    Vector256<float> opacity = Vector256.Create(Numerics.Clamp(amountBase, 0, 1F));
+
+                    destinationBase = PorterDuffFunctions.DarkenSrcIn(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.DarkenSrcIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.DarkenSrcIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
             }
         }
     }
@@ -1297,18 +3314,79 @@ internal static class DefaultPixelBlenders<TPixel>
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
         {
             amount = Numerics.Clamp(amount, 0, 1);
-            for (int i = 0; i < destination.Length; i++)
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.LightenSrcIn(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.LightenSrcIn(background[i], source[i], amount);
+                }
+            }
+            else
             {
-                destination[i] = PorterDuffFunctions.LightenSrcIn(background[i], source[i], amount);
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.LightenSrcIn(background[i], source[i], amount);
+                }
             }
         }
 
         /// <inheritdoc />
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
         {
-            for (int i = 0; i < destination.Length; i++)
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // TODO: It would be better if we can clamp this outside of the loop using our SIMD methods.
+                    Vector256<float> opacity = Vector256.Create(Numerics.Clamp(amountBase, 0, 1F));
+
+                    destinationBase = PorterDuffFunctions.LightenSrcIn(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.LightenSrcIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
             {
-                destination[i] = PorterDuffFunctions.LightenSrcIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1));
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.LightenSrcIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
             }
         }
     }
@@ -1335,18 +3413,79 @@ internal static class DefaultPixelBlenders<TPixel>
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
         {
             amount = Numerics.Clamp(amount, 0, 1);
-            for (int i = 0; i < destination.Length; i++)
+
+            if (Avx2.IsSupported && destination.Length >= 2)
             {
-                destination[i] = PorterDuffFunctions.OverlaySrcIn(background[i], source[i], amount);
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.OverlaySrcIn(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.OverlaySrcIn(background[i], source[i], amount);
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.OverlaySrcIn(background[i], source[i], amount);
+                }
             }
         }
 
         /// <inheritdoc />
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
         {
-            for (int i = 0; i < destination.Length; i++)
+            if (Avx2.IsSupported && destination.Length >= 2)
             {
-                destination[i] = PorterDuffFunctions.OverlaySrcIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1));
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // TODO: It would be better if we can clamp this outside of the loop using our SIMD methods.
+                    Vector256<float> opacity = Vector256.Create(Numerics.Clamp(amountBase, 0, 1F));
+
+                    destinationBase = PorterDuffFunctions.OverlaySrcIn(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.OverlaySrcIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.OverlaySrcIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
             }
         }
     }
@@ -1373,18 +3512,79 @@ internal static class DefaultPixelBlenders<TPixel>
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
         {
             amount = Numerics.Clamp(amount, 0, 1);
-            for (int i = 0; i < destination.Length; i++)
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.HardLightSrcIn(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.HardLightSrcIn(background[i], source[i], amount);
+                }
+            }
+            else
             {
-                destination[i] = PorterDuffFunctions.HardLightSrcIn(background[i], source[i], amount);
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.HardLightSrcIn(background[i], source[i], amount);
+                }
             }
         }
 
         /// <inheritdoc />
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
         {
-            for (int i = 0; i < destination.Length; i++)
+            if (Avx2.IsSupported && destination.Length >= 2)
             {
-                destination[i] = PorterDuffFunctions.HardLightSrcIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1));
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // TODO: It would be better if we can clamp this outside of the loop using our SIMD methods.
+                    Vector256<float> opacity = Vector256.Create(Numerics.Clamp(amountBase, 0, 1F));
+
+                    destinationBase = PorterDuffFunctions.HardLightSrcIn(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.HardLightSrcIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.HardLightSrcIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
             }
         }
     }
@@ -1411,18 +3611,79 @@ internal static class DefaultPixelBlenders<TPixel>
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
         {
             amount = Numerics.Clamp(amount, 0, 1);
-            for (int i = 0; i < destination.Length; i++)
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.NormalSrcOut(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.NormalSrcOut(background[i], source[i], amount);
+                }
+            }
+            else
             {
-                destination[i] = PorterDuffFunctions.NormalSrcOut(background[i], source[i], amount);
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.NormalSrcOut(background[i], source[i], amount);
+                }
             }
         }
 
         /// <inheritdoc />
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
         {
-            for (int i = 0; i < destination.Length; i++)
+            if (Avx2.IsSupported && destination.Length >= 2)
             {
-                destination[i] = PorterDuffFunctions.NormalSrcOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1));
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // TODO: It would be better if we can clamp this outside of the loop using our SIMD methods.
+                    Vector256<float> opacity = Vector256.Create(Numerics.Clamp(amountBase, 0, 1F));
+
+                    destinationBase = PorterDuffFunctions.NormalSrcOut(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.NormalSrcOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.NormalSrcOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
             }
         }
     }
@@ -1449,18 +3710,79 @@ internal static class DefaultPixelBlenders<TPixel>
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
         {
             amount = Numerics.Clamp(amount, 0, 1);
-            for (int i = 0; i < destination.Length; i++)
+
+            if (Avx2.IsSupported && destination.Length >= 2)
             {
-                destination[i] = PorterDuffFunctions.MultiplySrcOut(background[i], source[i], amount);
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.MultiplySrcOut(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.MultiplySrcOut(background[i], source[i], amount);
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.MultiplySrcOut(background[i], source[i], amount);
+                }
             }
         }
 
         /// <inheritdoc />
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
         {
-            for (int i = 0; i < destination.Length; i++)
+            if (Avx2.IsSupported && destination.Length >= 2)
             {
-                destination[i] = PorterDuffFunctions.MultiplySrcOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1));
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // TODO: It would be better if we can clamp this outside of the loop using our SIMD methods.
+                    Vector256<float> opacity = Vector256.Create(Numerics.Clamp(amountBase, 0, 1F));
+
+                    destinationBase = PorterDuffFunctions.MultiplySrcOut(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.MultiplySrcOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.MultiplySrcOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
             }
         }
     }
@@ -1487,18 +3809,79 @@ internal static class DefaultPixelBlenders<TPixel>
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
         {
             amount = Numerics.Clamp(amount, 0, 1);
-            for (int i = 0; i < destination.Length; i++)
+
+            if (Avx2.IsSupported && destination.Length >= 2)
             {
-                destination[i] = PorterDuffFunctions.AddSrcOut(background[i], source[i], amount);
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.AddSrcOut(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.AddSrcOut(background[i], source[i], amount);
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.AddSrcOut(background[i], source[i], amount);
+                }
             }
         }
 
         /// <inheritdoc />
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
         {
-            for (int i = 0; i < destination.Length; i++)
+            if (Avx2.IsSupported && destination.Length >= 2)
             {
-                destination[i] = PorterDuffFunctions.AddSrcOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1));
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // TODO: It would be better if we can clamp this outside of the loop using our SIMD methods.
+                    Vector256<float> opacity = Vector256.Create(Numerics.Clamp(amountBase, 0, 1F));
+
+                    destinationBase = PorterDuffFunctions.AddSrcOut(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.AddSrcOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.AddSrcOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
             }
         }
     }
@@ -1525,18 +3908,79 @@ internal static class DefaultPixelBlenders<TPixel>
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
         {
             amount = Numerics.Clamp(amount, 0, 1);
-            for (int i = 0; i < destination.Length; i++)
+
+            if (Avx2.IsSupported && destination.Length >= 2)
             {
-                destination[i] = PorterDuffFunctions.SubtractSrcOut(background[i], source[i], amount);
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.SubtractSrcOut(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.SubtractSrcOut(background[i], source[i], amount);
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.SubtractSrcOut(background[i], source[i], amount);
+                }
             }
         }
 
         /// <inheritdoc />
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
         {
-            for (int i = 0; i < destination.Length; i++)
+            if (Avx2.IsSupported && destination.Length >= 2)
             {
-                destination[i] = PorterDuffFunctions.SubtractSrcOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1));
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // TODO: It would be better if we can clamp this outside of the loop using our SIMD methods.
+                    Vector256<float> opacity = Vector256.Create(Numerics.Clamp(amountBase, 0, 1F));
+
+                    destinationBase = PorterDuffFunctions.SubtractSrcOut(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.SubtractSrcOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.SubtractSrcOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
             }
         }
     }
@@ -1563,18 +4007,79 @@ internal static class DefaultPixelBlenders<TPixel>
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
         {
             amount = Numerics.Clamp(amount, 0, 1);
-            for (int i = 0; i < destination.Length; i++)
+
+            if (Avx2.IsSupported && destination.Length >= 2)
             {
-                destination[i] = PorterDuffFunctions.ScreenSrcOut(background[i], source[i], amount);
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.ScreenSrcOut(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.ScreenSrcOut(background[i], source[i], amount);
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.ScreenSrcOut(background[i], source[i], amount);
+                }
             }
         }
 
         /// <inheritdoc />
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
         {
-            for (int i = 0; i < destination.Length; i++)
+            if (Avx2.IsSupported && destination.Length >= 2)
             {
-                destination[i] = PorterDuffFunctions.ScreenSrcOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1));
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // TODO: It would be better if we can clamp this outside of the loop using our SIMD methods.
+                    Vector256<float> opacity = Vector256.Create(Numerics.Clamp(amountBase, 0, 1F));
+
+                    destinationBase = PorterDuffFunctions.ScreenSrcOut(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.ScreenSrcOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.ScreenSrcOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
             }
         }
     }
@@ -1601,18 +4106,79 @@ internal static class DefaultPixelBlenders<TPixel>
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
         {
             amount = Numerics.Clamp(amount, 0, 1);
-            for (int i = 0; i < destination.Length; i++)
+
+            if (Avx2.IsSupported && destination.Length >= 2)
             {
-                destination[i] = PorterDuffFunctions.DarkenSrcOut(background[i], source[i], amount);
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.DarkenSrcOut(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.DarkenSrcOut(background[i], source[i], amount);
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.DarkenSrcOut(background[i], source[i], amount);
+                }
             }
         }
 
         /// <inheritdoc />
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
         {
-            for (int i = 0; i < destination.Length; i++)
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // TODO: It would be better if we can clamp this outside of the loop using our SIMD methods.
+                    Vector256<float> opacity = Vector256.Create(Numerics.Clamp(amountBase, 0, 1F));
+
+                    destinationBase = PorterDuffFunctions.DarkenSrcOut(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.DarkenSrcOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
             {
-                destination[i] = PorterDuffFunctions.DarkenSrcOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1));
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.DarkenSrcOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
             }
         }
     }
@@ -1639,18 +4205,79 @@ internal static class DefaultPixelBlenders<TPixel>
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
         {
             amount = Numerics.Clamp(amount, 0, 1);
-            for (int i = 0; i < destination.Length; i++)
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.LightenSrcOut(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.LightenSrcOut(background[i], source[i], amount);
+                }
+            }
+            else
             {
-                destination[i] = PorterDuffFunctions.LightenSrcOut(background[i], source[i], amount);
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.LightenSrcOut(background[i], source[i], amount);
+                }
             }
         }
 
         /// <inheritdoc />
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
         {
-            for (int i = 0; i < destination.Length; i++)
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // TODO: It would be better if we can clamp this outside of the loop using our SIMD methods.
+                    Vector256<float> opacity = Vector256.Create(Numerics.Clamp(amountBase, 0, 1F));
+
+                    destinationBase = PorterDuffFunctions.LightenSrcOut(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.LightenSrcOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
             {
-                destination[i] = PorterDuffFunctions.LightenSrcOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1));
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.LightenSrcOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
             }
         }
     }
@@ -1677,18 +4304,79 @@ internal static class DefaultPixelBlenders<TPixel>
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
         {
             amount = Numerics.Clamp(amount, 0, 1);
-            for (int i = 0; i < destination.Length; i++)
+
+            if (Avx2.IsSupported && destination.Length >= 2)
             {
-                destination[i] = PorterDuffFunctions.OverlaySrcOut(background[i], source[i], amount);
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.OverlaySrcOut(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.OverlaySrcOut(background[i], source[i], amount);
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.OverlaySrcOut(background[i], source[i], amount);
+                }
             }
         }
 
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            for (int i = 0; i < destination.Length; i++)
+        /// <inheritdoc />
+        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
+        {
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // TODO: It would be better if we can clamp this outside of the loop using our SIMD methods.
+                    Vector256<float> opacity = Vector256.Create(Numerics.Clamp(amountBase, 0, 1F));
+
+                    destinationBase = PorterDuffFunctions.OverlaySrcOut(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.OverlaySrcOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
             {
-                destination[i] = PorterDuffFunctions.OverlaySrcOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1));
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.OverlaySrcOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
             }
         }
     }
@@ -1715,18 +4403,79 @@ internal static class DefaultPixelBlenders<TPixel>
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
         {
             amount = Numerics.Clamp(amount, 0, 1);
-            for (int i = 0; i < destination.Length; i++)
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.HardLightSrcOut(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.HardLightSrcOut(background[i], source[i], amount);
+                }
+            }
+            else
             {
-                destination[i] = PorterDuffFunctions.HardLightSrcOut(background[i], source[i], amount);
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.HardLightSrcOut(background[i], source[i], amount);
+                }
             }
         }
 
         /// <inheritdoc />
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
         {
-            for (int i = 0; i < destination.Length; i++)
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // TODO: It would be better if we can clamp this outside of the loop using our SIMD methods.
+                    Vector256<float> opacity = Vector256.Create(Numerics.Clamp(amountBase, 0, 1F));
+
+                    destinationBase = PorterDuffFunctions.HardLightSrcOut(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.HardLightSrcOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
             {
-                destination[i] = PorterDuffFunctions.HardLightSrcOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1));
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.HardLightSrcOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
             }
         }
     }
@@ -1753,18 +4502,79 @@ internal static class DefaultPixelBlenders<TPixel>
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
         {
             amount = Numerics.Clamp(amount, 0, 1);
-            for (int i = 0; i < destination.Length; i++)
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.NormalDest(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.NormalDest(background[i], source[i], amount);
+                }
+            }
+            else
             {
-                destination[i] = PorterDuffFunctions.NormalDest(background[i], source[i], amount);
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.NormalDest(background[i], source[i], amount);
+                }
             }
         }
 
         /// <inheritdoc />
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
         {
-            for (int i = 0; i < destination.Length; i++)
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // TODO: It would be better if we can clamp this outside of the loop using our SIMD methods.
+                    Vector256<float> opacity = Vector256.Create(Numerics.Clamp(amountBase, 0, 1F));
+
+                    destinationBase = PorterDuffFunctions.NormalDest(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.NormalDest(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
             {
-                destination[i] = PorterDuffFunctions.NormalDest(background[i], source[i], Numerics.Clamp(amount[i], 0, 1));
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.NormalDest(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
             }
         }
     }
@@ -1791,18 +4601,79 @@ internal static class DefaultPixelBlenders<TPixel>
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
         {
             amount = Numerics.Clamp(amount, 0, 1);
-            for (int i = 0; i < destination.Length; i++)
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.MultiplyDest(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.MultiplyDest(background[i], source[i], amount);
+                }
+            }
+            else
             {
-                destination[i] = PorterDuffFunctions.MultiplyDest(background[i], source[i], amount);
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.MultiplyDest(background[i], source[i], amount);
+                }
             }
         }
 
         /// <inheritdoc />
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
         {
-            for (int i = 0; i < destination.Length; i++)
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // TODO: It would be better if we can clamp this outside of the loop using our SIMD methods.
+                    Vector256<float> opacity = Vector256.Create(Numerics.Clamp(amountBase, 0, 1F));
+
+                    destinationBase = PorterDuffFunctions.MultiplyDest(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.MultiplyDest(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
             {
-                destination[i] = PorterDuffFunctions.MultiplyDest(background[i], source[i], Numerics.Clamp(amount[i], 0, 1));
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.MultiplyDest(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
             }
         }
     }
@@ -1829,18 +4700,79 @@ internal static class DefaultPixelBlenders<TPixel>
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
         {
             amount = Numerics.Clamp(amount, 0, 1);
-            for (int i = 0; i < destination.Length; i++)
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.AddDest(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.AddDest(background[i], source[i], amount);
+                }
+            }
+            else
             {
-                destination[i] = PorterDuffFunctions.AddDest(background[i], source[i], amount);
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.AddDest(background[i], source[i], amount);
+                }
             }
         }
 
         /// <inheritdoc />
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
         {
-            for (int i = 0; i < destination.Length; i++)
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // TODO: It would be better if we can clamp this outside of the loop using our SIMD methods.
+                    Vector256<float> opacity = Vector256.Create(Numerics.Clamp(amountBase, 0, 1F));
+
+                    destinationBase = PorterDuffFunctions.AddDest(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.AddDest(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
             {
-                destination[i] = PorterDuffFunctions.AddDest(background[i], source[i], Numerics.Clamp(amount[i], 0, 1));
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.AddDest(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
             }
         }
     }
@@ -1867,18 +4799,79 @@ internal static class DefaultPixelBlenders<TPixel>
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
         {
             amount = Numerics.Clamp(amount, 0, 1);
-            for (int i = 0; i < destination.Length; i++)
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.SubtractDest(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.SubtractDest(background[i], source[i], amount);
+                }
+            }
+            else
             {
-                destination[i] = PorterDuffFunctions.SubtractDest(background[i], source[i], amount);
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.SubtractDest(background[i], source[i], amount);
+                }
             }
         }
 
         /// <inheritdoc />
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
         {
-            for (int i = 0; i < destination.Length; i++)
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // TODO: It would be better if we can clamp this outside of the loop using our SIMD methods.
+                    Vector256<float> opacity = Vector256.Create(Numerics.Clamp(amountBase, 0, 1F));
+
+                    destinationBase = PorterDuffFunctions.SubtractDest(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.SubtractDest(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
             {
-                destination[i] = PorterDuffFunctions.SubtractDest(background[i], source[i], Numerics.Clamp(amount[i], 0, 1));
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.SubtractDest(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
             }
         }
     }
@@ -1905,18 +4898,79 @@ internal static class DefaultPixelBlenders<TPixel>
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
         {
             amount = Numerics.Clamp(amount, 0, 1);
-            for (int i = 0; i < destination.Length; i++)
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.ScreenDest(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.ScreenDest(background[i], source[i], amount);
+                }
+            }
+            else
             {
-                destination[i] = PorterDuffFunctions.ScreenDest(background[i], source[i], amount);
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.ScreenDest(background[i], source[i], amount);
+                }
             }
         }
 
         /// <inheritdoc />
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
         {
-            for (int i = 0; i < destination.Length; i++)
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // TODO: It would be better if we can clamp this outside of the loop using our SIMD methods.
+                    Vector256<float> opacity = Vector256.Create(Numerics.Clamp(amountBase, 0, 1F));
+
+                    destinationBase = PorterDuffFunctions.ScreenDest(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.ScreenDest(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
             {
-                destination[i] = PorterDuffFunctions.ScreenDest(background[i], source[i], Numerics.Clamp(amount[i], 0, 1));
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.ScreenDest(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
             }
         }
     }
@@ -1943,18 +4997,79 @@ internal static class DefaultPixelBlenders<TPixel>
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
         {
             amount = Numerics.Clamp(amount, 0, 1);
-            for (int i = 0; i < destination.Length; i++)
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.DarkenDest(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.DarkenDest(background[i], source[i], amount);
+                }
+            }
+            else
             {
-                destination[i] = PorterDuffFunctions.DarkenDest(background[i], source[i], amount);
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.DarkenDest(background[i], source[i], amount);
+                }
             }
         }
 
         /// <inheritdoc />
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
         {
-            for (int i = 0; i < destination.Length; i++)
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // TODO: It would be better if we can clamp this outside of the loop using our SIMD methods.
+                    Vector256<float> opacity = Vector256.Create(Numerics.Clamp(amountBase, 0, 1F));
+
+                    destinationBase = PorterDuffFunctions.DarkenDest(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.DarkenDest(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
             {
-                destination[i] = PorterDuffFunctions.DarkenDest(background[i], source[i], Numerics.Clamp(amount[i], 0, 1));
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.DarkenDest(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
             }
         }
     }
@@ -1981,18 +5096,79 @@ internal static class DefaultPixelBlenders<TPixel>
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
         {
             amount = Numerics.Clamp(amount, 0, 1);
-            for (int i = 0; i < destination.Length; i++)
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.LightenDest(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.LightenDest(background[i], source[i], amount);
+                }
+            }
+            else
             {
-                destination[i] = PorterDuffFunctions.LightenDest(background[i], source[i], amount);
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.LightenDest(background[i], source[i], amount);
+                }
             }
         }
 
         /// <inheritdoc />
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
         {
-            for (int i = 0; i < destination.Length; i++)
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // TODO: It would be better if we can clamp this outside of the loop using our SIMD methods.
+                    Vector256<float> opacity = Vector256.Create(Numerics.Clamp(amountBase, 0, 1F));
+
+                    destinationBase = PorterDuffFunctions.LightenDest(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.LightenDest(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
             {
-                destination[i] = PorterDuffFunctions.LightenDest(background[i], source[i], Numerics.Clamp(amount[i], 0, 1));
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.LightenDest(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
             }
         }
     }
@@ -2019,18 +5195,79 @@ internal static class DefaultPixelBlenders<TPixel>
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
         {
             amount = Numerics.Clamp(amount, 0, 1);
-            for (int i = 0; i < destination.Length; i++)
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.OverlayDest(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.OverlayDest(background[i], source[i], amount);
+                }
+            }
+            else
             {
-                destination[i] = PorterDuffFunctions.OverlayDest(background[i], source[i], amount);
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.OverlayDest(background[i], source[i], amount);
+                }
             }
         }
 
         /// <inheritdoc />
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
         {
-            for (int i = 0; i < destination.Length; i++)
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // TODO: It would be better if we can clamp this outside of the loop using our SIMD methods.
+                    Vector256<float> opacity = Vector256.Create(Numerics.Clamp(amountBase, 0, 1F));
+
+                    destinationBase = PorterDuffFunctions.OverlayDest(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.OverlayDest(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
             {
-                destination[i] = PorterDuffFunctions.OverlayDest(background[i], source[i], Numerics.Clamp(amount[i], 0, 1));
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.OverlayDest(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
             }
         }
     }
@@ -2057,18 +5294,79 @@ internal static class DefaultPixelBlenders<TPixel>
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
         {
             amount = Numerics.Clamp(amount, 0, 1);
-            for (int i = 0; i < destination.Length; i++)
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.HardLightDest(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.HardLightDest(background[i], source[i], amount);
+                }
+            }
+            else
             {
-                destination[i] = PorterDuffFunctions.HardLightDest(background[i], source[i], amount);
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.HardLightDest(background[i], source[i], amount);
+                }
             }
         }
 
         /// <inheritdoc />
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
         {
-            for (int i = 0; i < destination.Length; i++)
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // TODO: It would be better if we can clamp this outside of the loop using our SIMD methods.
+                    Vector256<float> opacity = Vector256.Create(Numerics.Clamp(amountBase, 0, 1F));
+
+                    destinationBase = PorterDuffFunctions.HardLightDest(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.HardLightDest(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
             {
-                destination[i] = PorterDuffFunctions.HardLightDest(background[i], source[i], Numerics.Clamp(amount[i], 0, 1));
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.HardLightDest(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
             }
         }
     }
@@ -2095,18 +5393,79 @@ internal static class DefaultPixelBlenders<TPixel>
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
         {
             amount = Numerics.Clamp(amount, 0, 1);
-            for (int i = 0; i < destination.Length; i++)
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.NormalDestAtop(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.NormalDestAtop(background[i], source[i], amount);
+                }
+            }
+            else
             {
-                destination[i] = PorterDuffFunctions.NormalDestAtop(background[i], source[i], amount);
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.NormalDestAtop(background[i], source[i], amount);
+                }
             }
         }
 
         /// <inheritdoc />
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
         {
-            for (int i = 0; i < destination.Length; i++)
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // TODO: It would be better if we can clamp this outside of the loop using our SIMD methods.
+                    Vector256<float> opacity = Vector256.Create(Numerics.Clamp(amountBase, 0, 1F));
+
+                    destinationBase = PorterDuffFunctions.NormalDestAtop(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.NormalDestAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
             {
-                destination[i] = PorterDuffFunctions.NormalDestAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1));
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.NormalDestAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
             }
         }
     }
@@ -2133,18 +5492,79 @@ internal static class DefaultPixelBlenders<TPixel>
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
         {
             amount = Numerics.Clamp(amount, 0, 1);
-            for (int i = 0; i < destination.Length; i++)
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.MultiplyDestAtop(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.MultiplyDestAtop(background[i], source[i], amount);
+                }
+            }
+            else
             {
-                destination[i] = PorterDuffFunctions.MultiplyDestAtop(background[i], source[i], amount);
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.MultiplyDestAtop(background[i], source[i], amount);
+                }
             }
         }
 
         /// <inheritdoc />
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
         {
-            for (int i = 0; i < destination.Length; i++)
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // TODO: It would be better if we can clamp this outside of the loop using our SIMD methods.
+                    Vector256<float> opacity = Vector256.Create(Numerics.Clamp(amountBase, 0, 1F));
+
+                    destinationBase = PorterDuffFunctions.MultiplyDestAtop(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.MultiplyDestAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
             {
-                destination[i] = PorterDuffFunctions.MultiplyDestAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1));
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.MultiplyDestAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
             }
         }
     }
@@ -2171,18 +5591,79 @@ internal static class DefaultPixelBlenders<TPixel>
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
         {
             amount = Numerics.Clamp(amount, 0, 1);
-            for (int i = 0; i < destination.Length; i++)
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.AddDestAtop(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.AddDestAtop(background[i], source[i], amount);
+                }
+            }
+            else
             {
-                destination[i] = PorterDuffFunctions.AddDestAtop(background[i], source[i], amount);
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.AddDestAtop(background[i], source[i], amount);
+                }
             }
         }
 
         /// <inheritdoc />
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
         {
-            for (int i = 0; i < destination.Length; i++)
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // TODO: It would be better if we can clamp this outside of the loop using our SIMD methods.
+                    Vector256<float> opacity = Vector256.Create(Numerics.Clamp(amountBase, 0, 1F));
+
+                    destinationBase = PorterDuffFunctions.AddDestAtop(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.AddDestAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
             {
-                destination[i] = PorterDuffFunctions.AddDestAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1));
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.AddDestAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
             }
         }
     }
@@ -2209,18 +5690,79 @@ internal static class DefaultPixelBlenders<TPixel>
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
         {
             amount = Numerics.Clamp(amount, 0, 1);
-            for (int i = 0; i < destination.Length; i++)
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.SubtractDestAtop(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.SubtractDestAtop(background[i], source[i], amount);
+                }
+            }
+            else
             {
-                destination[i] = PorterDuffFunctions.SubtractDestAtop(background[i], source[i], amount);
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.SubtractDestAtop(background[i], source[i], amount);
+                }
             }
         }
 
         /// <inheritdoc />
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
         {
-            for (int i = 0; i < destination.Length; i++)
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // TODO: It would be better if we can clamp this outside of the loop using our SIMD methods.
+                    Vector256<float> opacity = Vector256.Create(Numerics.Clamp(amountBase, 0, 1F));
+
+                    destinationBase = PorterDuffFunctions.SubtractDestAtop(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.SubtractDestAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
             {
-                destination[i] = PorterDuffFunctions.SubtractDestAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1));
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.SubtractDestAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
             }
         }
     }
@@ -2247,18 +5789,79 @@ internal static class DefaultPixelBlenders<TPixel>
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
         {
             amount = Numerics.Clamp(amount, 0, 1);
-            for (int i = 0; i < destination.Length; i++)
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.ScreenDestAtop(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.ScreenDestAtop(background[i], source[i], amount);
+                }
+            }
+            else
             {
-                destination[i] = PorterDuffFunctions.ScreenDestAtop(background[i], source[i], amount);
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.ScreenDestAtop(background[i], source[i], amount);
+                }
             }
         }
 
         /// <inheritdoc />
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
         {
-            for (int i = 0; i < destination.Length; i++)
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // TODO: It would be better if we can clamp this outside of the loop using our SIMD methods.
+                    Vector256<float> opacity = Vector256.Create(Numerics.Clamp(amountBase, 0, 1F));
+
+                    destinationBase = PorterDuffFunctions.ScreenDestAtop(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.ScreenDestAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
             {
-                destination[i] = PorterDuffFunctions.ScreenDestAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1));
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.ScreenDestAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
             }
         }
     }
@@ -2285,18 +5888,79 @@ internal static class DefaultPixelBlenders<TPixel>
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
         {
             amount = Numerics.Clamp(amount, 0, 1);
-            for (int i = 0; i < destination.Length; i++)
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.DarkenDestAtop(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.DarkenDestAtop(background[i], source[i], amount);
+                }
+            }
+            else
             {
-                destination[i] = PorterDuffFunctions.DarkenDestAtop(background[i], source[i], amount);
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.DarkenDestAtop(background[i], source[i], amount);
+                }
             }
         }
 
         /// <inheritdoc />
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
         {
-            for (int i = 0; i < destination.Length; i++)
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // TODO: It would be better if we can clamp this outside of the loop using our SIMD methods.
+                    Vector256<float> opacity = Vector256.Create(Numerics.Clamp(amountBase, 0, 1F));
+
+                    destinationBase = PorterDuffFunctions.DarkenDestAtop(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.DarkenDestAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
             {
-                destination[i] = PorterDuffFunctions.DarkenDestAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1));
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.DarkenDestAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
             }
         }
     }
@@ -2323,18 +5987,79 @@ internal static class DefaultPixelBlenders<TPixel>
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
         {
             amount = Numerics.Clamp(amount, 0, 1);
-            for (int i = 0; i < destination.Length; i++)
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.LightenDestAtop(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.LightenDestAtop(background[i], source[i], amount);
+                }
+            }
+            else
             {
-                destination[i] = PorterDuffFunctions.LightenDestAtop(background[i], source[i], amount);
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.LightenDestAtop(background[i], source[i], amount);
+                }
             }
         }
 
         /// <inheritdoc />
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
         {
-            for (int i = 0; i < destination.Length; i++)
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // TODO: It would be better if we can clamp this outside of the loop using our SIMD methods.
+                    Vector256<float> opacity = Vector256.Create(Numerics.Clamp(amountBase, 0, 1F));
+
+                    destinationBase = PorterDuffFunctions.LightenDestAtop(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.LightenDestAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
             {
-                destination[i] = PorterDuffFunctions.LightenDestAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1));
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.LightenDestAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
             }
         }
     }
@@ -2361,18 +6086,79 @@ internal static class DefaultPixelBlenders<TPixel>
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
         {
             amount = Numerics.Clamp(amount, 0, 1);
-            for (int i = 0; i < destination.Length; i++)
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.OverlayDestAtop(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.OverlayDestAtop(background[i], source[i], amount);
+                }
+            }
+            else
             {
-                destination[i] = PorterDuffFunctions.OverlayDestAtop(background[i], source[i], amount);
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.OverlayDestAtop(background[i], source[i], amount);
+                }
             }
         }
 
         /// <inheritdoc />
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
         {
-            for (int i = 0; i < destination.Length; i++)
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // TODO: It would be better if we can clamp this outside of the loop using our SIMD methods.
+                    Vector256<float> opacity = Vector256.Create(Numerics.Clamp(amountBase, 0, 1F));
+
+                    destinationBase = PorterDuffFunctions.OverlayDestAtop(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.OverlayDestAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
             {
-                destination[i] = PorterDuffFunctions.OverlayDestAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1));
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.OverlayDestAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
             }
         }
     }
@@ -2399,18 +6185,79 @@ internal static class DefaultPixelBlenders<TPixel>
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
         {
             amount = Numerics.Clamp(amount, 0, 1);
-            for (int i = 0; i < destination.Length; i++)
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.HardLightDestAtop(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.HardLightDestAtop(background[i], source[i], amount);
+                }
+            }
+            else
             {
-                destination[i] = PorterDuffFunctions.HardLightDestAtop(background[i], source[i], amount);
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.HardLightDestAtop(background[i], source[i], amount);
+                }
             }
         }
 
         /// <inheritdoc />
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
         {
-            for (int i = 0; i < destination.Length; i++)
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // TODO: It would be better if we can clamp this outside of the loop using our SIMD methods.
+                    Vector256<float> opacity = Vector256.Create(Numerics.Clamp(amountBase, 0, 1F));
+
+                    destinationBase = PorterDuffFunctions.HardLightDestAtop(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.HardLightDestAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
             {
-                destination[i] = PorterDuffFunctions.HardLightDestAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1));
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.HardLightDestAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
             }
         }
     }
@@ -2437,18 +6284,79 @@ internal static class DefaultPixelBlenders<TPixel>
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
         {
             amount = Numerics.Clamp(amount, 0, 1);
-            for (int i = 0; i < destination.Length; i++)
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.NormalDestOver(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.NormalDestOver(background[i], source[i], amount);
+                }
+            }
+            else
             {
-                destination[i] = PorterDuffFunctions.NormalDestOver(background[i], source[i], amount);
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.NormalDestOver(background[i], source[i], amount);
+                }
             }
         }
 
         /// <inheritdoc />
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
         {
-            for (int i = 0; i < destination.Length; i++)
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // TODO: It would be better if we can clamp this outside of the loop using our SIMD methods.
+                    Vector256<float> opacity = Vector256.Create(Numerics.Clamp(amountBase, 0, 1F));
+
+                    destinationBase = PorterDuffFunctions.NormalDestOver(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.NormalDestOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
             {
-                destination[i] = PorterDuffFunctions.NormalDestOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1));
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.NormalDestOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
             }
         }
     }
@@ -2475,18 +6383,79 @@ internal static class DefaultPixelBlenders<TPixel>
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
         {
             amount = Numerics.Clamp(amount, 0, 1);
-            for (int i = 0; i < destination.Length; i++)
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.MultiplyDestOver(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.MultiplyDestOver(background[i], source[i], amount);
+                }
+            }
+            else
             {
-                destination[i] = PorterDuffFunctions.MultiplyDestOver(background[i], source[i], amount);
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.MultiplyDestOver(background[i], source[i], amount);
+                }
             }
         }
 
         /// <inheritdoc />
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
         {
-            for (int i = 0; i < destination.Length; i++)
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // TODO: It would be better if we can clamp this outside of the loop using our SIMD methods.
+                    Vector256<float> opacity = Vector256.Create(Numerics.Clamp(amountBase, 0, 1F));
+
+                    destinationBase = PorterDuffFunctions.MultiplyDestOver(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.MultiplyDestOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
             {
-                destination[i] = PorterDuffFunctions.MultiplyDestOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1));
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.MultiplyDestOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
             }
         }
     }
@@ -2513,18 +6482,79 @@ internal static class DefaultPixelBlenders<TPixel>
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
         {
             amount = Numerics.Clamp(amount, 0, 1);
-            for (int i = 0; i < destination.Length; i++)
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.AddDestOver(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.AddDestOver(background[i], source[i], amount);
+                }
+            }
+            else
             {
-                destination[i] = PorterDuffFunctions.AddDestOver(background[i], source[i], amount);
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.AddDestOver(background[i], source[i], amount);
+                }
             }
         }
 
         /// <inheritdoc />
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
         {
-            for (int i = 0; i < destination.Length; i++)
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // TODO: It would be better if we can clamp this outside of the loop using our SIMD methods.
+                    Vector256<float> opacity = Vector256.Create(Numerics.Clamp(amountBase, 0, 1F));
+
+                    destinationBase = PorterDuffFunctions.AddDestOver(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.AddDestOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
             {
-                destination[i] = PorterDuffFunctions.AddDestOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1));
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.AddDestOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
             }
         }
     }
@@ -2551,18 +6581,79 @@ internal static class DefaultPixelBlenders<TPixel>
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
         {
             amount = Numerics.Clamp(amount, 0, 1);
-            for (int i = 0; i < destination.Length; i++)
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.SubtractDestOver(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.SubtractDestOver(background[i], source[i], amount);
+                }
+            }
+            else
             {
-                destination[i] = PorterDuffFunctions.SubtractDestOver(background[i], source[i], amount);
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.SubtractDestOver(background[i], source[i], amount);
+                }
             }
         }
 
         /// <inheritdoc />
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
         {
-            for (int i = 0; i < destination.Length; i++)
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // TODO: It would be better if we can clamp this outside of the loop using our SIMD methods.
+                    Vector256<float> opacity = Vector256.Create(Numerics.Clamp(amountBase, 0, 1F));
+
+                    destinationBase = PorterDuffFunctions.SubtractDestOver(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.SubtractDestOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
             {
-                destination[i] = PorterDuffFunctions.SubtractDestOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1));
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.SubtractDestOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
             }
         }
     }
@@ -2589,18 +6680,79 @@ internal static class DefaultPixelBlenders<TPixel>
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
         {
             amount = Numerics.Clamp(amount, 0, 1);
-            for (int i = 0; i < destination.Length; i++)
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.ScreenDestOver(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.ScreenDestOver(background[i], source[i], amount);
+                }
+            }
+            else
             {
-                destination[i] = PorterDuffFunctions.ScreenDestOver(background[i], source[i], amount);
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.ScreenDestOver(background[i], source[i], amount);
+                }
             }
         }
 
         /// <inheritdoc />
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
         {
-            for (int i = 0; i < destination.Length; i++)
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // TODO: It would be better if we can clamp this outside of the loop using our SIMD methods.
+                    Vector256<float> opacity = Vector256.Create(Numerics.Clamp(amountBase, 0, 1F));
+
+                    destinationBase = PorterDuffFunctions.ScreenDestOver(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.ScreenDestOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
             {
-                destination[i] = PorterDuffFunctions.ScreenDestOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1));
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.ScreenDestOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
             }
         }
     }
@@ -2627,18 +6779,79 @@ internal static class DefaultPixelBlenders<TPixel>
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
         {
             amount = Numerics.Clamp(amount, 0, 1);
-            for (int i = 0; i < destination.Length; i++)
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.DarkenDestOver(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.DarkenDestOver(background[i], source[i], amount);
+                }
+            }
+            else
             {
-                destination[i] = PorterDuffFunctions.DarkenDestOver(background[i], source[i], amount);
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.DarkenDestOver(background[i], source[i], amount);
+                }
             }
         }
 
         /// <inheritdoc />
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
         {
-            for (int i = 0; i < destination.Length; i++)
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // TODO: It would be better if we can clamp this outside of the loop using our SIMD methods.
+                    Vector256<float> opacity = Vector256.Create(Numerics.Clamp(amountBase, 0, 1F));
+
+                    destinationBase = PorterDuffFunctions.DarkenDestOver(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.DarkenDestOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
             {
-                destination[i] = PorterDuffFunctions.DarkenDestOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1));
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.DarkenDestOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
             }
         }
     }
@@ -2665,18 +6878,79 @@ internal static class DefaultPixelBlenders<TPixel>
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
         {
             amount = Numerics.Clamp(amount, 0, 1);
-            for (int i = 0; i < destination.Length; i++)
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.LightenDestOver(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.LightenDestOver(background[i], source[i], amount);
+                }
+            }
+            else
             {
-                destination[i] = PorterDuffFunctions.LightenDestOver(background[i], source[i], amount);
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.LightenDestOver(background[i], source[i], amount);
+                }
             }
         }
 
         /// <inheritdoc />
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
         {
-            for (int i = 0; i < destination.Length; i++)
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // TODO: It would be better if we can clamp this outside of the loop using our SIMD methods.
+                    Vector256<float> opacity = Vector256.Create(Numerics.Clamp(amountBase, 0, 1F));
+
+                    destinationBase = PorterDuffFunctions.LightenDestOver(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.LightenDestOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
             {
-                destination[i] = PorterDuffFunctions.LightenDestOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1));
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.LightenDestOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
             }
         }
     }
@@ -2703,18 +6977,79 @@ internal static class DefaultPixelBlenders<TPixel>
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
         {
             amount = Numerics.Clamp(amount, 0, 1);
-            for (int i = 0; i < destination.Length; i++)
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.OverlayDestOver(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.OverlayDestOver(background[i], source[i], amount);
+                }
+            }
+            else
             {
-                destination[i] = PorterDuffFunctions.OverlayDestOver(background[i], source[i], amount);
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.OverlayDestOver(background[i], source[i], amount);
+                }
             }
         }
 
         /// <inheritdoc />
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
         {
-            for (int i = 0; i < destination.Length; i++)
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // TODO: It would be better if we can clamp this outside of the loop using our SIMD methods.
+                    Vector256<float> opacity = Vector256.Create(Numerics.Clamp(amountBase, 0, 1F));
+
+                    destinationBase = PorterDuffFunctions.OverlayDestOver(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.OverlayDestOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
             {
-                destination[i] = PorterDuffFunctions.OverlayDestOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1));
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.OverlayDestOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
             }
         }
     }
@@ -2741,18 +7076,79 @@ internal static class DefaultPixelBlenders<TPixel>
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
         {
             amount = Numerics.Clamp(amount, 0, 1);
-            for (int i = 0; i < destination.Length; i++)
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.HardLightDestOver(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.HardLightDestOver(background[i], source[i], amount);
+                }
+            }
+            else
             {
-                destination[i] = PorterDuffFunctions.HardLightDestOver(background[i], source[i], amount);
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.HardLightDestOver(background[i], source[i], amount);
+                }
             }
         }
 
         /// <inheritdoc />
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
         {
-            for (int i = 0; i < destination.Length; i++)
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // TODO: It would be better if we can clamp this outside of the loop using our SIMD methods.
+                    Vector256<float> opacity = Vector256.Create(Numerics.Clamp(amountBase, 0, 1F));
+
+                    destinationBase = PorterDuffFunctions.HardLightDestOver(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.HardLightDestOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
             {
-                destination[i] = PorterDuffFunctions.HardLightDestOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1));
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.HardLightDestOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
             }
         }
     }
@@ -2779,18 +7175,79 @@ internal static class DefaultPixelBlenders<TPixel>
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
         {
             amount = Numerics.Clamp(amount, 0, 1);
-            for (int i = 0; i < destination.Length; i++)
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.NormalDestIn(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.NormalDestIn(background[i], source[i], amount);
+                }
+            }
+            else
             {
-                destination[i] = PorterDuffFunctions.NormalDestIn(background[i], source[i], amount);
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.NormalDestIn(background[i], source[i], amount);
+                }
             }
         }
 
         /// <inheritdoc />
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
         {
-            for (int i = 0; i < destination.Length; i++)
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // TODO: It would be better if we can clamp this outside of the loop using our SIMD methods.
+                    Vector256<float> opacity = Vector256.Create(Numerics.Clamp(amountBase, 0, 1F));
+
+                    destinationBase = PorterDuffFunctions.NormalDestIn(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.NormalDestIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
             {
-                destination[i] = PorterDuffFunctions.NormalDestIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1));
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.NormalDestIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
             }
         }
     }
@@ -2817,18 +7274,79 @@ internal static class DefaultPixelBlenders<TPixel>
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
         {
             amount = Numerics.Clamp(amount, 0, 1);
-            for (int i = 0; i < destination.Length; i++)
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.MultiplyDestIn(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.MultiplyDestIn(background[i], source[i], amount);
+                }
+            }
+            else
             {
-                destination[i] = PorterDuffFunctions.MultiplyDestIn(background[i], source[i], amount);
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.MultiplyDestIn(background[i], source[i], amount);
+                }
             }
         }
 
         /// <inheritdoc />
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
         {
-            for (int i = 0; i < destination.Length; i++)
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // TODO: It would be better if we can clamp this outside of the loop using our SIMD methods.
+                    Vector256<float> opacity = Vector256.Create(Numerics.Clamp(amountBase, 0, 1F));
+
+                    destinationBase = PorterDuffFunctions.MultiplyDestIn(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.MultiplyDestIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
             {
-                destination[i] = PorterDuffFunctions.MultiplyDestIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1));
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.MultiplyDestIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
             }
         }
     }
@@ -2855,18 +7373,79 @@ internal static class DefaultPixelBlenders<TPixel>
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
         {
             amount = Numerics.Clamp(amount, 0, 1);
-            for (int i = 0; i < destination.Length; i++)
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.AddDestIn(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.AddDestIn(background[i], source[i], amount);
+                }
+            }
+            else
             {
-                destination[i] = PorterDuffFunctions.AddDestIn(background[i], source[i], amount);
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.AddDestIn(background[i], source[i], amount);
+                }
             }
         }
 
         /// <inheritdoc />
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
         {
-            for (int i = 0; i < destination.Length; i++)
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // TODO: It would be better if we can clamp this outside of the loop using our SIMD methods.
+                    Vector256<float> opacity = Vector256.Create(Numerics.Clamp(amountBase, 0, 1F));
+
+                    destinationBase = PorterDuffFunctions.AddDestIn(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.AddDestIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
             {
-                destination[i] = PorterDuffFunctions.AddDestIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1));
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.AddDestIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
             }
         }
     }
@@ -2893,18 +7472,79 @@ internal static class DefaultPixelBlenders<TPixel>
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
         {
             amount = Numerics.Clamp(amount, 0, 1);
-            for (int i = 0; i < destination.Length; i++)
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.SubtractDestIn(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.SubtractDestIn(background[i], source[i], amount);
+                }
+            }
+            else
             {
-                destination[i] = PorterDuffFunctions.SubtractDestIn(background[i], source[i], amount);
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.SubtractDestIn(background[i], source[i], amount);
+                }
             }
         }
 
         /// <inheritdoc />
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
         {
-            for (int i = 0; i < destination.Length; i++)
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // TODO: It would be better if we can clamp this outside of the loop using our SIMD methods.
+                    Vector256<float> opacity = Vector256.Create(Numerics.Clamp(amountBase, 0, 1F));
+
+                    destinationBase = PorterDuffFunctions.SubtractDestIn(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.SubtractDestIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
             {
-                destination[i] = PorterDuffFunctions.SubtractDestIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1));
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.SubtractDestIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
             }
         }
     }
@@ -2931,18 +7571,79 @@ internal static class DefaultPixelBlenders<TPixel>
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
         {
             amount = Numerics.Clamp(amount, 0, 1);
-            for (int i = 0; i < destination.Length; i++)
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.ScreenDestIn(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.ScreenDestIn(background[i], source[i], amount);
+                }
+            }
+            else
             {
-                destination[i] = PorterDuffFunctions.ScreenDestIn(background[i], source[i], amount);
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.ScreenDestIn(background[i], source[i], amount);
+                }
             }
         }
 
         /// <inheritdoc />
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
         {
-            for (int i = 0; i < destination.Length; i++)
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // TODO: It would be better if we can clamp this outside of the loop using our SIMD methods.
+                    Vector256<float> opacity = Vector256.Create(Numerics.Clamp(amountBase, 0, 1F));
+
+                    destinationBase = PorterDuffFunctions.ScreenDestIn(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.ScreenDestIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
             {
-                destination[i] = PorterDuffFunctions.ScreenDestIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1));
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.ScreenDestIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
             }
         }
     }
@@ -2969,18 +7670,79 @@ internal static class DefaultPixelBlenders<TPixel>
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
         {
             amount = Numerics.Clamp(amount, 0, 1);
-            for (int i = 0; i < destination.Length; i++)
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.DarkenDestIn(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.DarkenDestIn(background[i], source[i], amount);
+                }
+            }
+            else
             {
-                destination[i] = PorterDuffFunctions.DarkenDestIn(background[i], source[i], amount);
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.DarkenDestIn(background[i], source[i], amount);
+                }
             }
         }
 
         /// <inheritdoc />
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
         {
-            for (int i = 0; i < destination.Length; i++)
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // TODO: It would be better if we can clamp this outside of the loop using our SIMD methods.
+                    Vector256<float> opacity = Vector256.Create(Numerics.Clamp(amountBase, 0, 1F));
+
+                    destinationBase = PorterDuffFunctions.DarkenDestIn(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.DarkenDestIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
             {
-                destination[i] = PorterDuffFunctions.DarkenDestIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1));
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.DarkenDestIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
             }
         }
     }
@@ -3007,18 +7769,79 @@ internal static class DefaultPixelBlenders<TPixel>
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
         {
             amount = Numerics.Clamp(amount, 0, 1);
-            for (int i = 0; i < destination.Length; i++)
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.LightenDestIn(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.LightenDestIn(background[i], source[i], amount);
+                }
+            }
+            else
             {
-                destination[i] = PorterDuffFunctions.LightenDestIn(background[i], source[i], amount);
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.LightenDestIn(background[i], source[i], amount);
+                }
             }
         }
 
         /// <inheritdoc />
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
         {
-            for (int i = 0; i < destination.Length; i++)
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // TODO: It would be better if we can clamp this outside of the loop using our SIMD methods.
+                    Vector256<float> opacity = Vector256.Create(Numerics.Clamp(amountBase, 0, 1F));
+
+                    destinationBase = PorterDuffFunctions.LightenDestIn(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.LightenDestIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
             {
-                destination[i] = PorterDuffFunctions.LightenDestIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1));
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.LightenDestIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
             }
         }
     }
@@ -3045,18 +7868,79 @@ internal static class DefaultPixelBlenders<TPixel>
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
         {
             amount = Numerics.Clamp(amount, 0, 1);
-            for (int i = 0; i < destination.Length; i++)
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.OverlayDestIn(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.OverlayDestIn(background[i], source[i], amount);
+                }
+            }
+            else
             {
-                destination[i] = PorterDuffFunctions.OverlayDestIn(background[i], source[i], amount);
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.OverlayDestIn(background[i], source[i], amount);
+                }
             }
         }
 
         /// <inheritdoc />
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
         {
-            for (int i = 0; i < destination.Length; i++)
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // TODO: It would be better if we can clamp this outside of the loop using our SIMD methods.
+                    Vector256<float> opacity = Vector256.Create(Numerics.Clamp(amountBase, 0, 1F));
+
+                    destinationBase = PorterDuffFunctions.OverlayDestIn(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.OverlayDestIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
             {
-                destination[i] = PorterDuffFunctions.OverlayDestIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1));
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.OverlayDestIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
             }
         }
     }
@@ -3083,18 +7967,79 @@ internal static class DefaultPixelBlenders<TPixel>
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
         {
             amount = Numerics.Clamp(amount, 0, 1);
-            for (int i = 0; i < destination.Length; i++)
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.HardLightDestIn(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.HardLightDestIn(background[i], source[i], amount);
+                }
+            }
+            else
             {
-                destination[i] = PorterDuffFunctions.HardLightDestIn(background[i], source[i], amount);
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.HardLightDestIn(background[i], source[i], amount);
+                }
             }
         }
 
         /// <inheritdoc />
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
         {
-            for (int i = 0; i < destination.Length; i++)
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // TODO: It would be better if we can clamp this outside of the loop using our SIMD methods.
+                    Vector256<float> opacity = Vector256.Create(Numerics.Clamp(amountBase, 0, 1F));
+
+                    destinationBase = PorterDuffFunctions.HardLightDestIn(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.HardLightDestIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
             {
-                destination[i] = PorterDuffFunctions.HardLightDestIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1));
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.HardLightDestIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
             }
         }
     }
@@ -3121,18 +8066,79 @@ internal static class DefaultPixelBlenders<TPixel>
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
         {
             amount = Numerics.Clamp(amount, 0, 1);
-            for (int i = 0; i < destination.Length; i++)
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.NormalDestOut(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.NormalDestOut(background[i], source[i], amount);
+                }
+            }
+            else
             {
-                destination[i] = PorterDuffFunctions.NormalDestOut(background[i], source[i], amount);
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.NormalDestOut(background[i], source[i], amount);
+                }
             }
         }
 
         /// <inheritdoc />
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
         {
-            for (int i = 0; i < destination.Length; i++)
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // TODO: It would be better if we can clamp this outside of the loop using our SIMD methods.
+                    Vector256<float> opacity = Vector256.Create(Numerics.Clamp(amountBase, 0, 1F));
+
+                    destinationBase = PorterDuffFunctions.NormalDestOut(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.NormalDestOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
             {
-                destination[i] = PorterDuffFunctions.NormalDestOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1));
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.NormalDestOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
             }
         }
     }
@@ -3159,18 +8165,79 @@ internal static class DefaultPixelBlenders<TPixel>
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
         {
             amount = Numerics.Clamp(amount, 0, 1);
-            for (int i = 0; i < destination.Length; i++)
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.MultiplyDestOut(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.MultiplyDestOut(background[i], source[i], amount);
+                }
+            }
+            else
             {
-                destination[i] = PorterDuffFunctions.MultiplyDestOut(background[i], source[i], amount);
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.MultiplyDestOut(background[i], source[i], amount);
+                }
             }
         }
 
         /// <inheritdoc />
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
         {
-            for (int i = 0; i < destination.Length; i++)
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // TODO: It would be better if we can clamp this outside of the loop using our SIMD methods.
+                    Vector256<float> opacity = Vector256.Create(Numerics.Clamp(amountBase, 0, 1F));
+
+                    destinationBase = PorterDuffFunctions.MultiplyDestOut(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.MultiplyDestOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
             {
-                destination[i] = PorterDuffFunctions.MultiplyDestOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1));
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.MultiplyDestOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
             }
         }
     }
@@ -3197,18 +8264,79 @@ internal static class DefaultPixelBlenders<TPixel>
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
         {
             amount = Numerics.Clamp(amount, 0, 1);
-            for (int i = 0; i < destination.Length; i++)
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.AddDestOut(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.AddDestOut(background[i], source[i], amount);
+                }
+            }
+            else
             {
-                destination[i] = PorterDuffFunctions.AddDestOut(background[i], source[i], amount);
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.AddDestOut(background[i], source[i], amount);
+                }
             }
         }
 
         /// <inheritdoc />
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
         {
-            for (int i = 0; i < destination.Length; i++)
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // TODO: It would be better if we can clamp this outside of the loop using our SIMD methods.
+                    Vector256<float> opacity = Vector256.Create(Numerics.Clamp(amountBase, 0, 1F));
+
+                    destinationBase = PorterDuffFunctions.AddDestOut(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.AddDestOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
             {
-                destination[i] = PorterDuffFunctions.AddDestOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1));
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.AddDestOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
             }
         }
     }
@@ -3235,18 +8363,79 @@ internal static class DefaultPixelBlenders<TPixel>
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
         {
             amount = Numerics.Clamp(amount, 0, 1);
-            for (int i = 0; i < destination.Length; i++)
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.SubtractDestOut(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.SubtractDestOut(background[i], source[i], amount);
+                }
+            }
+            else
             {
-                destination[i] = PorterDuffFunctions.SubtractDestOut(background[i], source[i], amount);
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.SubtractDestOut(background[i], source[i], amount);
+                }
             }
         }
 
         /// <inheritdoc />
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
         {
-            for (int i = 0; i < destination.Length; i++)
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // TODO: It would be better if we can clamp this outside of the loop using our SIMD methods.
+                    Vector256<float> opacity = Vector256.Create(Numerics.Clamp(amountBase, 0, 1F));
+
+                    destinationBase = PorterDuffFunctions.SubtractDestOut(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.SubtractDestOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
             {
-                destination[i] = PorterDuffFunctions.SubtractDestOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1));
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.SubtractDestOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
             }
         }
     }
@@ -3273,18 +8462,79 @@ internal static class DefaultPixelBlenders<TPixel>
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
         {
             amount = Numerics.Clamp(amount, 0, 1);
-            for (int i = 0; i < destination.Length; i++)
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.ScreenDestOut(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.ScreenDestOut(background[i], source[i], amount);
+                }
+            }
+            else
             {
-                destination[i] = PorterDuffFunctions.ScreenDestOut(background[i], source[i], amount);
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.ScreenDestOut(background[i], source[i], amount);
+                }
             }
         }
 
         /// <inheritdoc />
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
         {
-            for (int i = 0; i < destination.Length; i++)
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // TODO: It would be better if we can clamp this outside of the loop using our SIMD methods.
+                    Vector256<float> opacity = Vector256.Create(Numerics.Clamp(amountBase, 0, 1F));
+
+                    destinationBase = PorterDuffFunctions.ScreenDestOut(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.ScreenDestOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
             {
-                destination[i] = PorterDuffFunctions.ScreenDestOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1));
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.ScreenDestOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
             }
         }
     }
@@ -3311,18 +8561,79 @@ internal static class DefaultPixelBlenders<TPixel>
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
         {
             amount = Numerics.Clamp(amount, 0, 1);
-            for (int i = 0; i < destination.Length; i++)
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.DarkenDestOut(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.DarkenDestOut(background[i], source[i], amount);
+                }
+            }
+            else
             {
-                destination[i] = PorterDuffFunctions.DarkenDestOut(background[i], source[i], amount);
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.DarkenDestOut(background[i], source[i], amount);
+                }
             }
         }
 
         /// <inheritdoc />
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
         {
-            for (int i = 0; i < destination.Length; i++)
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // TODO: It would be better if we can clamp this outside of the loop using our SIMD methods.
+                    Vector256<float> opacity = Vector256.Create(Numerics.Clamp(amountBase, 0, 1F));
+
+                    destinationBase = PorterDuffFunctions.DarkenDestOut(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.DarkenDestOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
             {
-                destination[i] = PorterDuffFunctions.DarkenDestOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1));
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.DarkenDestOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
             }
         }
     }
@@ -3349,18 +8660,79 @@ internal static class DefaultPixelBlenders<TPixel>
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
         {
             amount = Numerics.Clamp(amount, 0, 1);
-            for (int i = 0; i < destination.Length; i++)
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.LightenDestOut(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.LightenDestOut(background[i], source[i], amount);
+                }
+            }
+            else
             {
-                destination[i] = PorterDuffFunctions.LightenDestOut(background[i], source[i], amount);
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.LightenDestOut(background[i], source[i], amount);
+                }
             }
         }
 
         /// <inheritdoc />
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
         {
-            for (int i = 0; i < destination.Length; i++)
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // TODO: It would be better if we can clamp this outside of the loop using our SIMD methods.
+                    Vector256<float> opacity = Vector256.Create(Numerics.Clamp(amountBase, 0, 1F));
+
+                    destinationBase = PorterDuffFunctions.LightenDestOut(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.LightenDestOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
             {
-                destination[i] = PorterDuffFunctions.LightenDestOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1));
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.LightenDestOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
             }
         }
     }
@@ -3387,18 +8759,79 @@ internal static class DefaultPixelBlenders<TPixel>
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
         {
             amount = Numerics.Clamp(amount, 0, 1);
-            for (int i = 0; i < destination.Length; i++)
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.OverlayDestOut(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.OverlayDestOut(background[i], source[i], amount);
+                }
+            }
+            else
             {
-                destination[i] = PorterDuffFunctions.OverlayDestOut(background[i], source[i], amount);
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.OverlayDestOut(background[i], source[i], amount);
+                }
             }
         }
 
         /// <inheritdoc />
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
         {
-            for (int i = 0; i < destination.Length; i++)
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // TODO: It would be better if we can clamp this outside of the loop using our SIMD methods.
+                    Vector256<float> opacity = Vector256.Create(Numerics.Clamp(amountBase, 0, 1F));
+
+                    destinationBase = PorterDuffFunctions.OverlayDestOut(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.OverlayDestOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
             {
-                destination[i] = PorterDuffFunctions.OverlayDestOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1));
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.OverlayDestOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
             }
         }
     }
@@ -3425,18 +8858,79 @@ internal static class DefaultPixelBlenders<TPixel>
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
         {
             amount = Numerics.Clamp(amount, 0, 1);
-            for (int i = 0; i < destination.Length; i++)
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.HardLightDestOut(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.HardLightDestOut(background[i], source[i], amount);
+                }
+            }
+            else
             {
-                destination[i] = PorterDuffFunctions.HardLightDestOut(background[i], source[i], amount);
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.HardLightDestOut(background[i], source[i], amount);
+                }
             }
         }
 
         /// <inheritdoc />
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
         {
-            for (int i = 0; i < destination.Length; i++)
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // TODO: It would be better if we can clamp this outside of the loop using our SIMD methods.
+                    Vector256<float> opacity = Vector256.Create(Numerics.Clamp(amountBase, 0, 1F));
+
+                    destinationBase = PorterDuffFunctions.HardLightDestOut(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.HardLightDestOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
             {
-                destination[i] = PorterDuffFunctions.HardLightDestOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1));
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.HardLightDestOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
             }
         }
     }
@@ -3463,18 +8957,79 @@ internal static class DefaultPixelBlenders<TPixel>
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
         {
             amount = Numerics.Clamp(amount, 0, 1);
-            for (int i = 0; i < destination.Length; i++)
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.NormalClear(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.NormalClear(background[i], source[i], amount);
+                }
+            }
+            else
             {
-                destination[i] = PorterDuffFunctions.NormalClear(background[i], source[i], amount);
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.NormalClear(background[i], source[i], amount);
+                }
             }
         }
 
         /// <inheritdoc />
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
         {
-            for (int i = 0; i < destination.Length; i++)
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // TODO: It would be better if we can clamp this outside of the loop using our SIMD methods.
+                    Vector256<float> opacity = Vector256.Create(Numerics.Clamp(amountBase, 0, 1F));
+
+                    destinationBase = PorterDuffFunctions.NormalClear(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.NormalClear(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
             {
-                destination[i] = PorterDuffFunctions.NormalClear(background[i], source[i], Numerics.Clamp(amount[i], 0, 1));
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.NormalClear(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
             }
         }
     }
@@ -3501,18 +9056,79 @@ internal static class DefaultPixelBlenders<TPixel>
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
         {
             amount = Numerics.Clamp(amount, 0, 1);
-            for (int i = 0; i < destination.Length; i++)
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.MultiplyClear(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.MultiplyClear(background[i], source[i], amount);
+                }
+            }
+            else
             {
-                destination[i] = PorterDuffFunctions.MultiplyClear(background[i], source[i], amount);
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.MultiplyClear(background[i], source[i], amount);
+                }
             }
         }
 
         /// <inheritdoc />
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
         {
-            for (int i = 0; i < destination.Length; i++)
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // TODO: It would be better if we can clamp this outside of the loop using our SIMD methods.
+                    Vector256<float> opacity = Vector256.Create(Numerics.Clamp(amountBase, 0, 1F));
+
+                    destinationBase = PorterDuffFunctions.MultiplyClear(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.MultiplyClear(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
             {
-                destination[i] = PorterDuffFunctions.MultiplyClear(background[i], source[i], Numerics.Clamp(amount[i], 0, 1));
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.MultiplyClear(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
             }
         }
     }
@@ -3539,18 +9155,79 @@ internal static class DefaultPixelBlenders<TPixel>
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
         {
             amount = Numerics.Clamp(amount, 0, 1);
-            for (int i = 0; i < destination.Length; i++)
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.AddClear(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.AddClear(background[i], source[i], amount);
+                }
+            }
+            else
             {
-                destination[i] = PorterDuffFunctions.AddClear(background[i], source[i], amount);
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.AddClear(background[i], source[i], amount);
+                }
             }
         }
 
         /// <inheritdoc />
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
         {
-            for (int i = 0; i < destination.Length; i++)
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // TODO: It would be better if we can clamp this outside of the loop using our SIMD methods.
+                    Vector256<float> opacity = Vector256.Create(Numerics.Clamp(amountBase, 0, 1F));
+
+                    destinationBase = PorterDuffFunctions.AddClear(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.AddClear(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
             {
-                destination[i] = PorterDuffFunctions.AddClear(background[i], source[i], Numerics.Clamp(amount[i], 0, 1));
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.AddClear(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
             }
         }
     }
@@ -3577,18 +9254,79 @@ internal static class DefaultPixelBlenders<TPixel>
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
         {
             amount = Numerics.Clamp(amount, 0, 1);
-            for (int i = 0; i < destination.Length; i++)
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.SubtractClear(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.SubtractClear(background[i], source[i], amount);
+                }
+            }
+            else
             {
-                destination[i] = PorterDuffFunctions.SubtractClear(background[i], source[i], amount);
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.SubtractClear(background[i], source[i], amount);
+                }
             }
         }
 
         /// <inheritdoc />
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
         {
-            for (int i = 0; i < destination.Length; i++)
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // TODO: It would be better if we can clamp this outside of the loop using our SIMD methods.
+                    Vector256<float> opacity = Vector256.Create(Numerics.Clamp(amountBase, 0, 1F));
+
+                    destinationBase = PorterDuffFunctions.SubtractClear(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.SubtractClear(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
             {
-                destination[i] = PorterDuffFunctions.SubtractClear(background[i], source[i], Numerics.Clamp(amount[i], 0, 1));
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.SubtractClear(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
             }
         }
     }
@@ -3615,18 +9353,79 @@ internal static class DefaultPixelBlenders<TPixel>
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
         {
             amount = Numerics.Clamp(amount, 0, 1);
-            for (int i = 0; i < destination.Length; i++)
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.ScreenClear(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.ScreenClear(background[i], source[i], amount);
+                }
+            }
+            else
             {
-                destination[i] = PorterDuffFunctions.ScreenClear(background[i], source[i], amount);
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.ScreenClear(background[i], source[i], amount);
+                }
             }
         }
 
         /// <inheritdoc />
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
         {
-            for (int i = 0; i < destination.Length; i++)
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // TODO: It would be better if we can clamp this outside of the loop using our SIMD methods.
+                    Vector256<float> opacity = Vector256.Create(Numerics.Clamp(amountBase, 0, 1F));
+
+                    destinationBase = PorterDuffFunctions.ScreenClear(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.ScreenClear(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
             {
-                destination[i] = PorterDuffFunctions.ScreenClear(background[i], source[i], Numerics.Clamp(amount[i], 0, 1));
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.ScreenClear(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
             }
         }
     }
@@ -3653,18 +9452,79 @@ internal static class DefaultPixelBlenders<TPixel>
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
         {
             amount = Numerics.Clamp(amount, 0, 1);
-            for (int i = 0; i < destination.Length; i++)
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.DarkenClear(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.DarkenClear(background[i], source[i], amount);
+                }
+            }
+            else
             {
-                destination[i] = PorterDuffFunctions.DarkenClear(background[i], source[i], amount);
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.DarkenClear(background[i], source[i], amount);
+                }
             }
         }
 
         /// <inheritdoc />
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
         {
-            for (int i = 0; i < destination.Length; i++)
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // TODO: It would be better if we can clamp this outside of the loop using our SIMD methods.
+                    Vector256<float> opacity = Vector256.Create(Numerics.Clamp(amountBase, 0, 1F));
+
+                    destinationBase = PorterDuffFunctions.DarkenClear(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.DarkenClear(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
             {
-                destination[i] = PorterDuffFunctions.DarkenClear(background[i], source[i], Numerics.Clamp(amount[i], 0, 1));
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.DarkenClear(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
             }
         }
     }
@@ -3691,18 +9551,79 @@ internal static class DefaultPixelBlenders<TPixel>
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
         {
             amount = Numerics.Clamp(amount, 0, 1);
-            for (int i = 0; i < destination.Length; i++)
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.LightenClear(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.LightenClear(background[i], source[i], amount);
+                }
+            }
+            else
             {
-                destination[i] = PorterDuffFunctions.LightenClear(background[i], source[i], amount);
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.LightenClear(background[i], source[i], amount);
+                }
             }
         }
 
         /// <inheritdoc />
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
         {
-            for (int i = 0; i < destination.Length; i++)
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // TODO: It would be better if we can clamp this outside of the loop using our SIMD methods.
+                    Vector256<float> opacity = Vector256.Create(Numerics.Clamp(amountBase, 0, 1F));
+
+                    destinationBase = PorterDuffFunctions.LightenClear(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.LightenClear(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
             {
-                destination[i] = PorterDuffFunctions.LightenClear(background[i], source[i], Numerics.Clamp(amount[i], 0, 1));
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.LightenClear(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
             }
         }
     }
@@ -3729,18 +9650,79 @@ internal static class DefaultPixelBlenders<TPixel>
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
         {
             amount = Numerics.Clamp(amount, 0, 1);
-            for (int i = 0; i < destination.Length; i++)
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.OverlayClear(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.OverlayClear(background[i], source[i], amount);
+                }
+            }
+            else
             {
-                destination[i] = PorterDuffFunctions.OverlayClear(background[i], source[i], amount);
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.OverlayClear(background[i], source[i], amount);
+                }
             }
         }
 
         /// <inheritdoc />
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
         {
-            for (int i = 0; i < destination.Length; i++)
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // TODO: It would be better if we can clamp this outside of the loop using our SIMD methods.
+                    Vector256<float> opacity = Vector256.Create(Numerics.Clamp(amountBase, 0, 1F));
+
+                    destinationBase = PorterDuffFunctions.OverlayClear(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.OverlayClear(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
             {
-                destination[i] = PorterDuffFunctions.OverlayClear(background[i], source[i], Numerics.Clamp(amount[i], 0, 1));
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.OverlayClear(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
             }
         }
     }
@@ -3767,18 +9749,79 @@ internal static class DefaultPixelBlenders<TPixel>
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
         {
             amount = Numerics.Clamp(amount, 0, 1);
-            for (int i = 0; i < destination.Length; i++)
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.HardLightClear(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.HardLightClear(background[i], source[i], amount);
+                }
+            }
+            else
             {
-                destination[i] = PorterDuffFunctions.HardLightClear(background[i], source[i], amount);
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.HardLightClear(background[i], source[i], amount);
+                }
             }
         }
 
         /// <inheritdoc />
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
         {
-            for (int i = 0; i < destination.Length; i++)
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // TODO: It would be better if we can clamp this outside of the loop using our SIMD methods.
+                    Vector256<float> opacity = Vector256.Create(Numerics.Clamp(amountBase, 0, 1F));
+
+                    destinationBase = PorterDuffFunctions.HardLightClear(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.HardLightClear(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
             {
-                destination[i] = PorterDuffFunctions.HardLightClear(background[i], source[i], Numerics.Clamp(amount[i], 0, 1));
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.HardLightClear(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
             }
         }
     }
@@ -3805,18 +9848,79 @@ internal static class DefaultPixelBlenders<TPixel>
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
         {
             amount = Numerics.Clamp(amount, 0, 1);
-            for (int i = 0; i < destination.Length; i++)
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.NormalXor(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.NormalXor(background[i], source[i], amount);
+                }
+            }
+            else
             {
-                destination[i] = PorterDuffFunctions.NormalXor(background[i], source[i], amount);
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.NormalXor(background[i], source[i], amount);
+                }
             }
         }
 
         /// <inheritdoc />
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
         {
-            for (int i = 0; i < destination.Length; i++)
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // TODO: It would be better if we can clamp this outside of the loop using our SIMD methods.
+                    Vector256<float> opacity = Vector256.Create(Numerics.Clamp(amountBase, 0, 1F));
+
+                    destinationBase = PorterDuffFunctions.NormalXor(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.NormalXor(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
             {
-                destination[i] = PorterDuffFunctions.NormalXor(background[i], source[i], Numerics.Clamp(amount[i], 0, 1));
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.NormalXor(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
             }
         }
     }
@@ -3843,18 +9947,79 @@ internal static class DefaultPixelBlenders<TPixel>
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
         {
             amount = Numerics.Clamp(amount, 0, 1);
-            for (int i = 0; i < destination.Length; i++)
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.MultiplyXor(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.MultiplyXor(background[i], source[i], amount);
+                }
+            }
+            else
             {
-                destination[i] = PorterDuffFunctions.MultiplyXor(background[i], source[i], amount);
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.MultiplyXor(background[i], source[i], amount);
+                }
             }
         }
 
         /// <inheritdoc />
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
         {
-            for (int i = 0; i < destination.Length; i++)
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // TODO: It would be better if we can clamp this outside of the loop using our SIMD methods.
+                    Vector256<float> opacity = Vector256.Create(Numerics.Clamp(amountBase, 0, 1F));
+
+                    destinationBase = PorterDuffFunctions.MultiplyXor(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.MultiplyXor(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
             {
-                destination[i] = PorterDuffFunctions.MultiplyXor(background[i], source[i], Numerics.Clamp(amount[i], 0, 1));
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.MultiplyXor(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
             }
         }
     }
@@ -3881,18 +10046,79 @@ internal static class DefaultPixelBlenders<TPixel>
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
         {
             amount = Numerics.Clamp(amount, 0, 1);
-            for (int i = 0; i < destination.Length; i++)
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.AddXor(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.AddXor(background[i], source[i], amount);
+                }
+            }
+            else
             {
-                destination[i] = PorterDuffFunctions.AddXor(background[i], source[i], amount);
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.AddXor(background[i], source[i], amount);
+                }
             }
         }
 
         /// <inheritdoc />
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
         {
-            for (int i = 0; i < destination.Length; i++)
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // TODO: It would be better if we can clamp this outside of the loop using our SIMD methods.
+                    Vector256<float> opacity = Vector256.Create(Numerics.Clamp(amountBase, 0, 1F));
+
+                    destinationBase = PorterDuffFunctions.AddXor(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.AddXor(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
             {
-                destination[i] = PorterDuffFunctions.AddXor(background[i], source[i], Numerics.Clamp(amount[i], 0, 1));
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.AddXor(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
             }
         }
     }
@@ -3919,18 +10145,79 @@ internal static class DefaultPixelBlenders<TPixel>
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
         {
             amount = Numerics.Clamp(amount, 0, 1);
-            for (int i = 0; i < destination.Length; i++)
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.SubtractXor(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.SubtractXor(background[i], source[i], amount);
+                }
+            }
+            else
             {
-                destination[i] = PorterDuffFunctions.SubtractXor(background[i], source[i], amount);
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.SubtractXor(background[i], source[i], amount);
+                }
             }
         }
 
         /// <inheritdoc />
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
         {
-            for (int i = 0; i < destination.Length; i++)
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // TODO: It would be better if we can clamp this outside of the loop using our SIMD methods.
+                    Vector256<float> opacity = Vector256.Create(Numerics.Clamp(amountBase, 0, 1F));
+
+                    destinationBase = PorterDuffFunctions.SubtractXor(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.SubtractXor(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
             {
-                destination[i] = PorterDuffFunctions.SubtractXor(background[i], source[i], Numerics.Clamp(amount[i], 0, 1));
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.SubtractXor(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
             }
         }
     }
@@ -3957,18 +10244,79 @@ internal static class DefaultPixelBlenders<TPixel>
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
         {
             amount = Numerics.Clamp(amount, 0, 1);
-            for (int i = 0; i < destination.Length; i++)
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.ScreenXor(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.ScreenXor(background[i], source[i], amount);
+                }
+            }
+            else
             {
-                destination[i] = PorterDuffFunctions.ScreenXor(background[i], source[i], amount);
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.ScreenXor(background[i], source[i], amount);
+                }
             }
         }
 
         /// <inheritdoc />
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
         {
-            for (int i = 0; i < destination.Length; i++)
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // TODO: It would be better if we can clamp this outside of the loop using our SIMD methods.
+                    Vector256<float> opacity = Vector256.Create(Numerics.Clamp(amountBase, 0, 1F));
+
+                    destinationBase = PorterDuffFunctions.ScreenXor(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.ScreenXor(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
             {
-                destination[i] = PorterDuffFunctions.ScreenXor(background[i], source[i], Numerics.Clamp(amount[i], 0, 1));
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.ScreenXor(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
             }
         }
     }
@@ -3995,18 +10343,79 @@ internal static class DefaultPixelBlenders<TPixel>
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
         {
             amount = Numerics.Clamp(amount, 0, 1);
-            for (int i = 0; i < destination.Length; i++)
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.DarkenXor(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.DarkenXor(background[i], source[i], amount);
+                }
+            }
+            else
             {
-                destination[i] = PorterDuffFunctions.DarkenXor(background[i], source[i], amount);
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.DarkenXor(background[i], source[i], amount);
+                }
             }
         }
 
         /// <inheritdoc />
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
         {
-            for (int i = 0; i < destination.Length; i++)
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // TODO: It would be better if we can clamp this outside of the loop using our SIMD methods.
+                    Vector256<float> opacity = Vector256.Create(Numerics.Clamp(amountBase, 0, 1F));
+
+                    destinationBase = PorterDuffFunctions.DarkenXor(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.DarkenXor(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
             {
-                destination[i] = PorterDuffFunctions.DarkenXor(background[i], source[i], Numerics.Clamp(amount[i], 0, 1));
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.DarkenXor(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
             }
         }
     }
@@ -4033,18 +10442,79 @@ internal static class DefaultPixelBlenders<TPixel>
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
         {
             amount = Numerics.Clamp(amount, 0, 1);
-            for (int i = 0; i < destination.Length; i++)
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.LightenXor(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.LightenXor(background[i], source[i], amount);
+                }
+            }
+            else
             {
-                destination[i] = PorterDuffFunctions.LightenXor(background[i], source[i], amount);
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.LightenXor(background[i], source[i], amount);
+                }
             }
         }
 
         /// <inheritdoc />
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
         {
-            for (int i = 0; i < destination.Length; i++)
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // TODO: It would be better if we can clamp this outside of the loop using our SIMD methods.
+                    Vector256<float> opacity = Vector256.Create(Numerics.Clamp(amountBase, 0, 1F));
+
+                    destinationBase = PorterDuffFunctions.LightenXor(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.LightenXor(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
             {
-                destination[i] = PorterDuffFunctions.LightenXor(background[i], source[i], Numerics.Clamp(amount[i], 0, 1));
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.LightenXor(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
             }
         }
     }
@@ -4071,18 +10541,79 @@ internal static class DefaultPixelBlenders<TPixel>
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
         {
             amount = Numerics.Clamp(amount, 0, 1);
-            for (int i = 0; i < destination.Length; i++)
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.OverlayXor(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.OverlayXor(background[i], source[i], amount);
+                }
+            }
+            else
             {
-                destination[i] = PorterDuffFunctions.OverlayXor(background[i], source[i], amount);
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.OverlayXor(background[i], source[i], amount);
+                }
             }
         }
 
         /// <inheritdoc />
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
         {
-            for (int i = 0; i < destination.Length; i++)
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // TODO: It would be better if we can clamp this outside of the loop using our SIMD methods.
+                    Vector256<float> opacity = Vector256.Create(Numerics.Clamp(amountBase, 0, 1F));
+
+                    destinationBase = PorterDuffFunctions.OverlayXor(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.OverlayXor(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
             {
-                destination[i] = PorterDuffFunctions.OverlayXor(background[i], source[i], Numerics.Clamp(amount[i], 0, 1));
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.OverlayXor(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
             }
         }
     }
@@ -4109,18 +10640,79 @@ internal static class DefaultPixelBlenders<TPixel>
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
         {
             amount = Numerics.Clamp(amount, 0, 1);
-            for (int i = 0; i < destination.Length; i++)
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.HardLightXor(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.HardLightXor(background[i], source[i], amount);
+                }
+            }
+            else
             {
-                destination[i] = PorterDuffFunctions.HardLightXor(background[i], source[i], amount);
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.HardLightXor(background[i], source[i], amount);
+                }
             }
         }
 
         /// <inheritdoc />
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
         {
-            for (int i = 0; i < destination.Length; i++)
-            {
-                destination[i] = PorterDuffFunctions.HardLightXor(background[i], source[i], Numerics.Clamp(amount[i], 0, 1));
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // TODO: It would be better if we can clamp this outside of the loop using our SIMD methods.
+                    Vector256<float> opacity = Vector256.Create(Numerics.Clamp(amountBase, 0, 1F));
+
+                    destinationBase = PorterDuffFunctions.HardLightXor(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.HardLightXor(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.HardLightXor(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
             }
         }
     }
diff --git a/src/ImageSharp/PixelFormats/PixelBlenders/DefaultPixelBlenders.Generated.tt b/src/ImageSharp/PixelFormats/PixelBlenders/DefaultPixelBlenders.Generated.tt
index 7bd51439c..6d98c6cd9 100644
--- a/src/ImageSharp/PixelFormats/PixelBlenders/DefaultPixelBlenders.Generated.tt
+++ b/src/ImageSharp/PixelFormats/PixelBlenders/DefaultPixelBlenders.Generated.tt
@@ -13,6 +13,10 @@
 
 // <auto-generated />
 using System.Numerics;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using System.Runtime.Intrinsics;
+using System.Runtime.Intrinsics.X86;
 
 namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders;
 
@@ -86,18 +90,79 @@ var blenders = new []{
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
         {
             amount = Numerics.Clamp(amount, 0, 1);
-            for (int i = 0; i < destination.Length; i++)
+
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                Vector256<float> opacity = Vector256.Create(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    destinationBase = PorterDuffFunctions.<#=blender_composer#>(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.<#=blender_composer#>(background[i], source[i], amount);
+                }
+            }
+            else
             {
-                destination[i] = PorterDuffFunctions.<#=blender_composer#>(background[i], source[i], amount);
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.<#=blender_composer#>(background[i], source[i], amount);
+                }
             }
         }
 
         /// <inheritdoc />
         protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
         {
-            for (int i = 0; i < destination.Length; i++)
+            if (Avx2.IsSupported && destination.Length >= 2)
+            {
+                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (IntPtr)((uint)destination.Length / 2u));
+
+                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
+                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+
+                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
+                {
+                    // TODO: It would be better if we can clamp this outside of the loop using our SIMD methods.
+                    Vector256<float> opacity = Vector256.Create(Numerics.Clamp(amountBase, 0, 1F));
+
+                    destinationBase = PorterDuffFunctions.<#=blender_composer#>(backgroundBase, sourceBase, opacity);
+                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
+                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
+                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
+                    amountBase = ref Unsafe.Add(ref amountBase, 1);
+                }
+
+                if (Numerics.Modulo2(destination.Length) != 0)
+                {
+                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                    int i = destination.Length - 1;
+                    destination[i] = PorterDuffFunctions.<#=blender_composer#>(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
+            }
+            else
             {
-                destination[i] = PorterDuffFunctions.<#=blender_composer#>(background[i], source[i], Numerics.Clamp(amount[i], 0, 1));
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = PorterDuffFunctions.<#=blender_composer#>(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
+                }
             }
         }
     }