diff --git a/src/ImageSharp/Common/Helpers/SimdUtils.BasicIntrinsics256.cs b/src/ImageSharp/Common/Helpers/SimdUtils.BasicIntrinsics256.cs
index 690bf83095..ba3d9c4e83 100644
--- a/src/ImageSharp/Common/Helpers/SimdUtils.BasicIntrinsics256.cs
+++ b/src/ImageSharp/Common/Helpers/SimdUtils.BasicIntrinsics256.cs
@@ -17,7 +17,7 @@ namespace SixLabors.ImageSharp
         /// </summary>
         public static class BasicIntrinsics256
         {
-            public static bool IsAvailable { get; } = IsAvx2CompatibleArchitecture;
+            public static bool IsAvailable { get; } = HasVector8;
 
 #if !SUPPORTS_EXTENDED_INTRINSICS
             /// <summary>
@@ -86,7 +86,7 @@ namespace SixLabors.ImageSharp
             /// </summary>
             internal static void BulkConvertByteToNormalizedFloat(ReadOnlySpan<byte> source, Span<float> dest)
             {
-                VerifyIsAvx2Compatible(nameof(BulkConvertByteToNormalizedFloat));
+                VerifyHasVector8(nameof(BulkConvertByteToNormalizedFloat));
                 VerifySpanInput(source, dest, 8);
 
                 var bVec = new Vector<float>(256.0f / 255.0f);
@@ -128,7 +128,7 @@ namespace SixLabors.ImageSharp
             /// </summary>
             internal static void BulkConvertNormalizedFloatToByteClampOverflows(ReadOnlySpan<float> source, Span<byte> dest)
             {
-                VerifyIsAvx2Compatible(nameof(BulkConvertNormalizedFloatToByteClampOverflows));
+                VerifyHasVector8(nameof(BulkConvertNormalizedFloatToByteClampOverflows));
                 VerifySpanInput(source, dest, 8);
 
                 if (source.Length == 0)
@@ -177,7 +177,7 @@ namespace SixLabors.ImageSharp
             /// </summary>
             internal static void BulkConvertNormalizedFloatToByte(ReadOnlySpan<float> source, Span<byte> dest)
             {
-                VerifyIsAvx2Compatible(nameof(BulkConvertNormalizedFloatToByte));
+                VerifyHasVector8(nameof(BulkConvertNormalizedFloatToByte));
                 VerifySpanInput(source, dest, 8);
 
                 if (source.Length == 0)
diff --git a/src/ImageSharp/Common/Helpers/SimdUtils.cs b/src/ImageSharp/Common/Helpers/SimdUtils.cs
index 4c34e28bc8..08c256f842 100644
--- a/src/ImageSharp/Common/Helpers/SimdUtils.cs
+++ b/src/ImageSharp/Common/Helpers/SimdUtils.cs
@@ -15,9 +15,10 @@ namespace SixLabors.ImageSharp
     internal static partial class SimdUtils
     {
         /// <summary>
-        /// Gets a value indicating whether the code is being executed on AVX2 CPU where both float and integer registers are of size 256 byte.
+        /// Gets a value indicating whether <see cref="Vector{T}"/> code is being JIT-ed to AVX2 instructions
+        /// where both float and integer registers are of size 256 byte.
         /// </summary>
-        public static bool IsAvx2CompatibleArchitecture { get; } =
+        public static bool HasVector8 { get; } =
             Vector.IsHardwareAccelerated && Vector<float>.Count == 8 && Vector<int>.Count == 8;
 
         /// <summary>
@@ -151,9 +152,9 @@ namespace SixLabors.ImageSharp
         private static byte ConvertToByte(float f) => (byte)ComparableExtensions.Clamp((f * 255f) + 0.5f, 0, 255f);
 
         [Conditional("DEBUG")]
-        private static void VerifyIsAvx2Compatible(string operation)
+        private static void VerifyHasVector8(string operation)
         {
-            if (!IsAvx2CompatibleArchitecture)
+            if (!HasVector8)
             {
                 throw new NotSupportedException($"{operation} is supported only on AVX2 CPU!");
             }
diff --git a/src/ImageSharp/Common/Tuples/Vector4Pair.cs b/src/ImageSharp/Common/Tuples/Vector4Pair.cs
index b3a32deeef..1fdae0d5dd 100644
--- a/src/ImageSharp/Common/Tuples/Vector4Pair.cs
+++ b/src/ImageSharp/Common/Tuples/Vector4Pair.cs
@@ -44,7 +44,7 @@ namespace SixLabors.ImageSharp.Tuples
         /// Downscale method, specific to Jpeg color conversion. Works only if Vector{float}.Count == 4!        /// TODO: Move it somewhere else.
         /// </summary>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        internal void RoundAndDownscalePreAvx2(float downscaleFactor)
+        internal void RoundAndDownscalePreVector8(float downscaleFactor)
         {
             ref Vector<float> a = ref Unsafe.As<Vector4, Vector<float>>(ref this.A);
             a = a.FastRound();
@@ -63,7 +63,7 @@ namespace SixLabors.ImageSharp.Tuples
         /// TODO: Move it somewhere else.
         /// </summary>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        internal void RoundAndDownscaleAvx2(float downscaleFactor)
+        internal void RoundAndDownscaleVector8(float downscaleFactor)
         {
             ref Vector<float> self = ref Unsafe.As<Vector4Pair, Vector<float>>(ref this);
             Vector<float> v = self;
@@ -79,4 +79,4 @@ namespace SixLabors.ImageSharp.Tuples
             return $"{nameof(Vector4Pair)}({this.A}, {this.B})";
         }
     }
-}
\ No newline at end of file
+}
diff --git a/src/ImageSharp/Formats/Jpeg/Components/Block8x8F.Generated.cs b/src/ImageSharp/Formats/Jpeg/Components/Block8x8F.Generated.cs
index 23b51f0926..033eedb924 100644
--- a/src/ImageSharp/Formats/Jpeg/Components/Block8x8F.Generated.cs
+++ b/src/ImageSharp/Formats/Jpeg/Components/Block8x8F.Generated.cs
@@ -121,7 +121,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components
         /// AVX2-only variant for executing <see cref="NormalizeColorsInplace"/> and <see cref="RoundInplace"/> in one step.
         /// </summary>
         [MethodImpl(InliningOptions.ShortMethod)]
-        public void NormalizeColorsAndRoundInplaceAvx2(float maximum)
+        public void NormalizeColorsAndRoundInplaceVector8(float maximum)
         {
             var off = new Vector<float>(MathF.Ceiling(maximum / 2));
             var max = new Vector<float>(maximum);
diff --git a/src/ImageSharp/Formats/Jpeg/Components/Block8x8F.Generated.tt b/src/ImageSharp/Formats/Jpeg/Components/Block8x8F.Generated.tt
index 176591972a..5370f27048 100644
--- a/src/ImageSharp/Formats/Jpeg/Components/Block8x8F.Generated.tt
+++ b/src/ImageSharp/Formats/Jpeg/Components/Block8x8F.Generated.tt
@@ -84,7 +84,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components
         /// AVX2-only variant for executing <see cref="NormalizeColorsInplace"/> and <see cref="RoundInplace"/> in one step.
         /// </summary>
         [MethodImpl(InliningOptions.ShortMethod)]
-        public void NormalizeColorsAndRoundInplaceAvx2(float maximum)
+        public void NormalizeColorsAndRoundInplaceVector8(float maximum)
         {
             var off = new Vector<float>(MathF.Ceiling(maximum / 2));
             var max = new Vector<float>(maximum);
diff --git a/src/ImageSharp/Formats/Jpeg/Components/Block8x8F.cs b/src/ImageSharp/Formats/Jpeg/Components/Block8x8F.cs
index f11b0f8fa7..f2a81e5c83 100644
--- a/src/ImageSharp/Formats/Jpeg/Components/Block8x8F.cs
+++ b/src/ImageSharp/Formats/Jpeg/Components/Block8x8F.cs
@@ -471,9 +471,9 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components
         /// </summary>
         public void NormalizeColorsAndRoundInplace(float maximum)
         {
-            if (SimdUtils.IsAvx2CompatibleArchitecture)
+            if (SimdUtils.HasVector8)
             {
-                this.NormalizeColorsAndRoundInplaceAvx2(maximum);
+                this.NormalizeColorsAndRoundInplaceVector8(maximum);
             }
             else
             {
@@ -497,7 +497,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components
         public void LoadFrom(ref Block8x8 source)
         {
 #if SUPPORTS_EXTENDED_INTRINSICS
-            if (SimdUtils.IsAvx2CompatibleArchitecture)
+            if (SimdUtils.HasVector8)
             {
                 this.LoadFromInt16ExtendedAvx2(ref source);
                 return;
@@ -513,7 +513,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components
         public void LoadFromInt16ExtendedAvx2(ref Block8x8 source)
         {
             DebugGuard.IsTrue(
-                SimdUtils.IsAvx2CompatibleArchitecture,
+                SimdUtils.HasVector8,
                 "LoadFromUInt16ExtendedAvx2 only works on AVX2 compatible architecture!");
 
             ref Vector<short> sRef = ref Unsafe.As<Block8x8, Vector<short>>(ref source);
diff --git a/src/ImageSharp/Formats/Jpeg/Components/Decoder/ColorConverters/JpegColorConverter.FromYCbCrSimd.cs b/src/ImageSharp/Formats/Jpeg/Components/Decoder/ColorConverters/JpegColorConverter.FromYCbCrSimd.cs
index 1706b4c1bc..09d6a4d1d8 100644
--- a/src/ImageSharp/Formats/Jpeg/Components/Decoder/ColorConverters/JpegColorConverter.FromYCbCrSimd.cs
+++ b/src/ImageSharp/Formats/Jpeg/Components/Decoder/ColorConverters/JpegColorConverter.FromYCbCrSimd.cs
@@ -90,15 +90,15 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder.ColorConverters
                     if (Vector<float>.Count == 4)
                     {
                         // TODO: Find a way to properly run & test this path on AVX2 PC-s! (Have I already mentioned that Vector<T> is terrible?)
-                        r.RoundAndDownscalePreAvx2(maxValue);
-                        g.RoundAndDownscalePreAvx2(maxValue);
-                        b.RoundAndDownscalePreAvx2(maxValue);
+                        r.RoundAndDownscalePreVector8(maxValue);
+                        g.RoundAndDownscalePreVector8(maxValue);
+                        b.RoundAndDownscalePreVector8(maxValue);
                     }
-                    else if (SimdUtils.IsAvx2CompatibleArchitecture)
+                    else if (SimdUtils.HasVector8)
                     {
-                        r.RoundAndDownscaleAvx2(maxValue);
-                        g.RoundAndDownscaleAvx2(maxValue);
-                        b.RoundAndDownscaleAvx2(maxValue);
+                        r.RoundAndDownscaleVector8(maxValue);
+                        g.RoundAndDownscaleVector8(maxValue);
+                        b.RoundAndDownscaleVector8(maxValue);
                     }
                     else
                     {
@@ -114,4 +114,4 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder.ColorConverters
             }
         }
     }
-}
\ No newline at end of file
+}
diff --git a/src/ImageSharp/Formats/Jpeg/Components/Decoder/ColorConverters/JpegColorConverter.FromYCbCrSimdAvx2.cs b/src/ImageSharp/Formats/Jpeg/Components/Decoder/ColorConverters/JpegColorConverter.FromYCbCrSimdAvx2.cs
index 093ea2f9a2..1165db2802 100644
--- a/src/ImageSharp/Formats/Jpeg/Components/Decoder/ColorConverters/JpegColorConverter.FromYCbCrSimdAvx2.cs
+++ b/src/ImageSharp/Formats/Jpeg/Components/Decoder/ColorConverters/JpegColorConverter.FromYCbCrSimdAvx2.cs
@@ -20,7 +20,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder.ColorConverters
             {
             }
 
-            public static bool IsAvailable => Vector.IsHardwareAccelerated && SimdUtils.IsAvx2CompatibleArchitecture;
+            public static bool IsAvailable => Vector.IsHardwareAccelerated && SimdUtils.HasVector8;
 
             public override void ConvertToRgba(in ComponentValues values, Span<Vector4> result)
             {
diff --git a/src/ImageSharp/PixelFormats/Utils/Vector4Converters.RgbaCompatible.cs b/src/ImageSharp/PixelFormats/Utils/Vector4Converters.RgbaCompatible.cs
index 11a23b6eb2..af04a06b7b 100644
--- a/src/ImageSharp/PixelFormats/Utils/Vector4Converters.RgbaCompatible.cs
+++ b/src/ImageSharp/PixelFormats/Utils/Vector4Converters.RgbaCompatible.cs
@@ -122,7 +122,7 @@ namespace SixLabors.ImageSharp.PixelFormats.Utils
                     return int.MaxValue;
                 }
 
-                return SimdUtils.ExtendedIntrinsics.IsAvailable && SimdUtils.IsAvx2CompatibleArchitecture ? 256 : 128;
+                return SimdUtils.ExtendedIntrinsics.IsAvailable && SimdUtils.HasVector8 ? 256 : 128;
             }
         }
     }
diff --git a/tests/ImageSharp.Benchmarks/Codecs/Jpeg/BlockOperations/Block8x8F_CopyTo1x1.cs b/tests/ImageSharp.Benchmarks/Codecs/Jpeg/BlockOperations/Block8x8F_CopyTo1x1.cs
index 3f54d68c95..b97ca14f38 100644
--- a/tests/ImageSharp.Benchmarks/Codecs/Jpeg/BlockOperations/Block8x8F_CopyTo1x1.cs
+++ b/tests/ImageSharp.Benchmarks/Codecs/Jpeg/BlockOperations/Block8x8F_CopyTo1x1.cs
@@ -32,7 +32,7 @@ namespace SixLabors.ImageSharp.Benchmarks.Codecs.Jpeg.BlockOperations
         [GlobalSetup]
         public void Setup()
         {
-            if (!SimdUtils.IsAvx2CompatibleArchitecture)
+            if (!SimdUtils.HasVector8)
             {
                 throw new InvalidOperationException("Benchmark Block8x8F_CopyTo1x1 is invalid on platforms without AVX2 support.");
             }
diff --git a/tests/ImageSharp.Tests/Common/SimdUtilsTests.cs b/tests/ImageSharp.Tests/Common/SimdUtilsTests.cs
index 6bf3d07457..cc5519c795 100644
--- a/tests/ImageSharp.Tests/Common/SimdUtilsTests.cs
+++ b/tests/ImageSharp.Tests/Common/SimdUtilsTests.cs
@@ -105,7 +105,7 @@ namespace SixLabors.ImageSharp.Tests.Common
 
         private bool SkipOnNonAvx2([CallerMemberName] string testCaseName = null)
         {
-            if (!SimdUtils.IsAvx2CompatibleArchitecture)
+            if (!SimdUtils.HasVector8)
             {
                 this.Output.WriteLine("Skipping AVX2 specific test case: " + testCaseName);
                 return true;
diff --git a/tests/ImageSharp.Tests/Formats/Jpg/Block8x8FTests.cs b/tests/ImageSharp.Tests/Formats/Jpg/Block8x8FTests.cs
index ef8804242f..2af8dfe797 100644
--- a/tests/ImageSharp.Tests/Formats/Jpg/Block8x8FTests.cs
+++ b/tests/ImageSharp.Tests/Formats/Jpg/Block8x8FTests.cs
@@ -29,7 +29,7 @@ namespace SixLabors.ImageSharp.Tests.Formats.Jpg
 
         private bool SkipOnNonAvx2Runner()
         {
-            if (!SimdUtils.IsAvx2CompatibleArchitecture)
+            if (!SimdUtils.HasVector8)
             {
                 this.Output.WriteLine("AVX2 not supported, skipping!");
                 return true;
@@ -257,7 +257,7 @@ namespace SixLabors.ImageSharp.Tests.Formats.Jpg
             expected.RoundInplace();
 
             Block8x8F actual = source;
-            actual.NormalizeColorsAndRoundInplaceAvx2(255);
+            actual.NormalizeColorsAndRoundInplaceVector8(255);
 
             this.Output.WriteLine(expected.ToString());
             this.Output.WriteLine(actual.ToString());
diff --git a/tests/ImageSharp.Tests/Formats/Jpg/JpegColorConverterTests.cs b/tests/ImageSharp.Tests/Formats/Jpg/JpegColorConverterTests.cs
index 8775714257..7f0033cc5c 100644
--- a/tests/ImageSharp.Tests/Formats/Jpg/JpegColorConverterTests.cs
+++ b/tests/ImageSharp.Tests/Formats/Jpg/JpegColorConverterTests.cs
@@ -99,7 +99,7 @@ namespace SixLabors.ImageSharp.Tests.Formats.Jpg
         [MemberData(nameof(CommonConversionData))]
         public void FromYCbCrSimdAvx2(int inputBufferLength, int resultBufferLength, int seed)
         {
-            if (!SimdUtils.IsAvx2CompatibleArchitecture)
+            if (!SimdUtils.HasVector8)
             {
                 this.Output.WriteLine("No AVX2 present, skipping test!");
                 return;
diff --git a/tests/ImageSharp.Tests/ProfilingBenchmarks/JpegProfilingBenchmarks.cs b/tests/ImageSharp.Tests/ProfilingBenchmarks/JpegProfilingBenchmarks.cs
index 987de29ea9..358a5d0a01 100644
--- a/tests/ImageSharp.Tests/ProfilingBenchmarks/JpegProfilingBenchmarks.cs
+++ b/tests/ImageSharp.Tests/ProfilingBenchmarks/JpegProfilingBenchmarks.cs
@@ -30,12 +30,12 @@ namespace SixLabors.ImageSharp.Tests.ProfilingBenchmarks
             { TestImages.Jpeg.BenchmarkSuite.Jpeg400_SmallMonochrome, 20 },
             { TestImages.Jpeg.BenchmarkSuite.Jpeg420Exif_MidSizeYCbCr, 20 },
             { TestImages.Jpeg.BenchmarkSuite.Lake_Small444YCbCr, 40 },
-            // TestImages.Jpeg.BenchmarkSuite.MissingFF00ProgressiveBedroom159_MidSize420YCbCr,
-            // TestImages.Jpeg.BenchmarkSuite.BadRstProgressive518_Large444YCbCr,
+            // { TestImages.Jpeg.BenchmarkSuite.MissingFF00ProgressiveBedroom159_MidSize420YCbCr, 10 },
+            // { TestImages.Jpeg.BenchmarkSuite.BadRstProgressive518_Large444YCbCr, 5 },
             { TestImages.Jpeg.BenchmarkSuite.ExifGetString750Transform_Huge420YCbCr, 5 }
         };
 
-        [Theory(Skip = ProfilingSetup.SkipProfilingTests)]
+        [Theory]
         [MemberData(nameof(DecodeJpegData))]
         public void DecodeJpeg(string fileName, int executionCount)
         {
diff --git a/tests/ImageSharp.Tests/ProfilingBenchmarks/ResizeProfilingBenchmarks.cs b/tests/ImageSharp.Tests/ProfilingBenchmarks/ResizeProfilingBenchmarks.cs
index ba5eb532b2..9b8a3d5a35 100644
--- a/tests/ImageSharp.Tests/ProfilingBenchmarks/ResizeProfilingBenchmarks.cs
+++ b/tests/ImageSharp.Tests/ProfilingBenchmarks/ResizeProfilingBenchmarks.cs
@@ -21,7 +21,7 @@ namespace SixLabors.ImageSharp.Tests.ProfilingBenchmarks
 
         public int ExecutionCount { get; set; } = 50;
 
-        [Theory(Skip = ProfilingSetup.SkipProfilingTests)]
+        [Theory]
         [InlineData(100, 100)]
         [InlineData(2000, 2000)]
         public void ResizeBicubic(int width, int height)